chardev/char.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include "qemu-common.h"
  26 #include "qemu/cutils.h"
  27 #include "monitor/monitor.h"
  28 #include "sysemu/sysemu.h"
  29 #include "sysemu/block-backend.h"
  30 #include "qemu/error-report.h"
  31 #include "qemu/timer.h"
  32 #include "sysemu/char.h"
  33 #include "hw/usb.h"
  34 #include "qmp-commands.h"
  35 #include "qapi/clone-visitor.h"
  36 #include "qapi-visit.h"
  37 #include "qemu/base64.h"
  38 #include "io/channel-socket.h"
  39 #include "io/channel-file.h"
  40 #include "io/channel-tls.h"
  41 #include "sysemu/replay.h"
  42 #include "qemu/help_option.h"
  43
  44 #include <zlib.h>
  45
  46 #ifndef _WIN32
  47 #include <sys/times.h>
  48 #include <sys/wait.h>
  49 #include <termios.h>
  50 #include <sys/ioctl.h>
  51 #include <sys/resource.h>
  52 #include <sys/socket.h>
  53 #include <netinet/in.h>
  54 #include <net/if.h>
  55 #include <arpa/inet.h>
  56 #include <netdb.h>
  57 #include <sys/select.h>
  58 #ifdef CONFIG_BSD
  59 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  60 #include <dev/ppbus/ppi.h>
  61 #include <dev/ppbus/ppbconf.h>
  62 #elif defined(__DragonFly__)
  63 #include <dev/misc/ppi/ppi.h>
  64 #include <bus/ppbus/ppbconf.h>
  65 #endif
  66 #else
  67 #ifdef __linux__
  68 #include <linux/ppdev.h>
  69 #include <linux/parport.h>
  70 #endif
  71 #ifdef __sun__
  72 #include <sys/ethernet.h>
  73 #include <sys/sockio.h>
  74 #include <netinet/arp.h>
  75 #include <netinet/in.h>
  76 #include <netinet/in_systm.h>
  77 #include <netinet/ip.h>
  78 #include <netinet/ip_icmp.h> // must come after ip.h
  79 #include <netinet/udp.h>
  80 #include <netinet/tcp.h>
  81 #endif
  82 #endif
  83 #endif
  84
  85 #include "qemu/sockets.h"
  86 #include "ui/qemu-spice.h"
  87
  88 #include "char-mux.h"
  89 #include "char-fd.h"
  90 #include "char-io.h"
  91 #ifdef _WIN32
  92 #include "char-win.h"
  93 #endif
  94
  95 /***********************************************************/
  96 /* character device */
  97
  98 static QTAILQ_HEAD(ChardevHead, Chardev) chardevs =
  99     QTAILQ_HEAD_INITIALIZER(chardevs);
 100
 101 void qemu_chr_be_event(Chardev *s, int event)
 102 {
 103     CharBackend *be = s->be;
 104
 105     /* Keep track if the char device is open */
 106     switch (event) {
 107         case CHR_EVENT_OPENED:
 108             s->be_open = 1;
 109             break;
 110         case CHR_EVENT_CLOSED:
 111             s->be_open = 0;
 112             break;
 113     }
 114
 115     if (!be || !be->chr_event) {
 116         return;
 117     }
 118
 119     be->chr_event(be->opaque, event);
 120 }
 121
 122 void qemu_chr_be_generic_open(Chardev *s)
 123 {
 124     qemu_chr_be_event(s, CHR_EVENT_OPENED);
 125 }
 126
 127
 128 /* Not reporting errors from writing to logfile, as logs are
 129  * defined to be "best effort" only */
 130 static void qemu_chr_fe_write_log(Chardev *s,
 131                                   const uint8_t *buf, size_t len)
 132 {
 133     size_t done = 0;
 134     ssize_t ret;
 135
 136     if (s->logfd < 0) {
 137         return;
 138     }
 139
 140     while (done < len) {
 141     retry:
 142         ret = write(s->logfd, buf + done, len - done);
 143         if (ret == -1 && errno == EAGAIN) {
 144             g_usleep(100);
 145             goto retry;
 146         }
 147
 148         if (ret <= 0) {
 149             return;
 150         }
 151         done += ret;
 152     }
 153 }
 154
 155 static int qemu_chr_fe_write_buffer(Chardev *s,
 156                                     const uint8_t *buf, int len, int *offset)
 157 {
 158     ChardevClass *cc = CHARDEV_GET_CLASS(s);
 159     int res = 0;
 160     *offset = 0;
 161
 162     qemu_mutex_lock(&s->chr_write_lock);
 163     while (*offset < len) {
 164     retry:
 165         res = cc->chr_write(s, buf + *offset, len - *offset);
 166         if (res < 0 && errno == EAGAIN) {
 167             g_usleep(100);
 168             goto retry;
 169         }
 170
 171         if (res <= 0) {
 172             break;
 173         }
 174
 175         *offset += res;
 176     }
 177     if (*offset > 0) {
 178         qemu_chr_fe_write_log(s, buf, *offset);
 179     }
 180     qemu_mutex_unlock(&s->chr_write_lock);
 181
 182     return res;
 183 }
 184
 185 static bool qemu_chr_replay(Chardev *chr)
 186 {
 187     return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
 188 }
 189
 190 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
 191 {
 192     Chardev *s = be->chr;
 193     ChardevClass *cc;
 194     int ret;
 195
 196     if (!s) {
 197         return 0;
 198     }
 199
 200     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 201         int offset;
 202         replay_char_write_event_load(&ret, &offset);
 203         assert(offset <= len);
 204         qemu_chr_fe_write_buffer(s, buf, offset, &offset);
 205         return ret;
 206     }
 207
 208     cc = CHARDEV_GET_CLASS(s);
 209     qemu_mutex_lock(&s->chr_write_lock);
 210     ret = cc->chr_write(s, buf, len);
 211
 212     if (ret > 0) {
 213         qemu_chr_fe_write_log(s, buf, ret);
 214     }
 215
 216     qemu_mutex_unlock(&s->chr_write_lock);
 217
 218     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 219         replay_char_write_event_save(ret, ret < 0 ? 0 : ret);
 220     }
 221
 222     return ret;
 223 }
 224
 225 int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)
 226 {
 227     int offset;
 228     int res;
 229
 230     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 231         replay_char_write_event_load(&res, &offset);
 232         assert(offset <= len);
 233         qemu_chr_fe_write_buffer(s, buf, offset, &offset);
 234         return res;
 235     }
 236
 237     res = qemu_chr_fe_write_buffer(s, buf, len, &offset);
 238
 239     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 240         replay_char_write_event_save(res, offset);
 241     }
 242
 243     if (res < 0) {
 244         return res;
 245     }
 246     return offset;
 247 }
 248
 249 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
 250 {
 251     Chardev *s = be->chr;
 252
 253     if (!s) {
 254         return 0;
 255     }
 256
 257     return qemu_chr_write_all(s, buf, len);
 258 }
 259
 260 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
 261 {
 262     Chardev *s = be->chr;
 263     int offset = 0, counter = 10;
 264     int res;
 265
 266     if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
 267         return 0;
 268     }
 269
 270     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 271         return replay_char_read_all_load(buf);
 272     }
 273
 274     while (offset < len) {
 275     retry:
 276         res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
 277                                                   len - offset);
 278         if (res == -1 && errno == EAGAIN) {
 279             g_usleep(100);
 280             goto retry;
 281         }
 282
 283         if (res == 0) {
 284             break;
 285         }
 286
 287         if (res < 0) {
 288             if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 289                 replay_char_read_all_save_error(res);
 290             }
 291             return res;
 292         }
 293
 294         offset += res;
 295
 296         if (!counter--) {
 297             break;
 298         }
 299     }
 300
 301     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 302         replay_char_read_all_save_buf(buf, offset);
 303     }
 304     return offset;
 305 }
 306
 307 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
 308 {
 309     Chardev *s = be->chr;
 310     int res;
 311
 312     if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
 313         res = -ENOTSUP;
 314     } else {
 315         res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
 316     }
 317
 318     return res;
 319 }
 320
 321 int qemu_chr_be_can_write(Chardev *s)
 322 {
 323     CharBackend *be = s->be;
 324
 325     if (!be || !be->chr_can_read) {
 326         return 0;
 327     }
 328
 329     return be->chr_can_read(be->opaque);
 330 }
 331
 332 void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len)
 333 {
 334     CharBackend *be = s->be;
 335
 336     if (be && be->chr_read) {
 337         be->chr_read(be->opaque, buf, len);
 338     }
 339 }
 340
 341 void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len)
 342 {
 343     if (qemu_chr_replay(s)) {
 344         if (replay_mode == REPLAY_MODE_PLAY) {
 345             return;
 346         }
 347         replay_chr_be_write(s, buf, len);
 348     } else {
 349         qemu_chr_be_write_impl(s, buf, len);
 350     }
 351 }
 352
 353 int qemu_chr_fe_get_msgfd(CharBackend *be)
 354 {
 355     Chardev *s = be->chr;
 356     int fd;
 357     int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
 358     if (s && qemu_chr_replay(s)) {
 359         error_report("Replay: get msgfd is not supported "
 360                      "for serial devices yet");
 361         exit(1);
 362     }
 363     return res;
 364 }
 365
 366 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
 367 {
 368     Chardev *s = be->chr;
 369
 370     if (!s) {
 371         return -1;
 372     }
 373
 374     return CHARDEV_GET_CLASS(s)->get_msgfds ?
 375         CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
 376 }
 377
 378 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
 379 {
 380     Chardev *s = be->chr;
 381
 382     if (!s) {
 383         return -1;
 384     }
 385
 386     return CHARDEV_GET_CLASS(s)->set_msgfds ?
 387         CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
 388 }
 389
 390 int qemu_chr_add_client(Chardev *s, int fd)
 391 {
 392     return CHARDEV_GET_CLASS(s)->chr_add_client ?
 393         CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
 394 }
 395
 396 void qemu_chr_fe_accept_input(CharBackend *be)
 397 {
 398     Chardev *s = be->chr;
 399
 400     if (!s) {
 401         return;
 402     }
 403
 404     if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
 405         CHARDEV_GET_CLASS(s)->chr_accept_input(s);
 406     }
 407     qemu_notify_event();
 408 }
 409
 410 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
 411 {
 412     char buf[CHR_READ_BUF_LEN];
 413     va_list ap;
 414     va_start(ap, fmt);
 415     vsnprintf(buf, sizeof(buf), fmt, ap);
 416     /* XXX this blocks entire thread. Rewrite to use
 417      * qemu_chr_fe_write and background I/O callbacks */
 418     qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
 419     va_end(ap);
 420 }
 421
 422 static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
 423                            bool *be_opened, Error **errp)
 424 {
 425     ChardevClass *cc = CHARDEV_GET_CLASS(chr);
 426     /* Any ChardevCommon member would work */
 427     ChardevCommon *common = backend ? backend->u.null.data : NULL;
 428
 429     if (common && common->has_logfile) {
 430         int flags = O_WRONLY | O_CREAT;
 431         if (common->has_logappend &&
 432             common->logappend) {
 433             flags |= O_APPEND;
 434         } else {
 435             flags |= O_TRUNC;
 436         }
 437         chr->logfd = qemu_open(common->logfile, flags, 0666);
 438         if (chr->logfd < 0) {
 439             error_setg_errno(errp, errno,
 440                              "Unable to open logfile %s",
 441                              common->logfile);
 442             return;
 443         }
 444     }
 445
 446     if (cc->open) {
 447         cc->open(chr, backend, be_opened, errp);
 448     }
 449 }
 450
 451 static void char_init(Object *obj)
 452 {
 453     Chardev *chr = CHARDEV(obj);
 454
 455     chr->logfd = -1;
 456     qemu_mutex_init(&chr->chr_write_lock);
 457 }
 458
 459 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
 460 {
 461     return len;
 462 }
 463
 464 static void char_class_init(ObjectClass *oc, void *data)
 465 {
 466     ChardevClass *cc = CHARDEV_CLASS(oc);
 467
 468     cc->chr_write = null_chr_write;
 469 }
 470
 471 static void char_finalize(Object *obj)
 472 {
 473     Chardev *chr = CHARDEV(obj);
 474
 475     if (chr->be) {
 476         chr->be->chr = NULL;
 477     }
 478     g_free(chr->filename);
 479     g_free(chr->label);
 480     if (chr->logfd != -1) {
 481         close(chr->logfd);
 482     }
 483     qemu_mutex_destroy(&chr->chr_write_lock);
 484 }
 485
 486 static const TypeInfo char_type_info = {
 487     .name = TYPE_CHARDEV,
 488     .parent = TYPE_OBJECT,
 489     .instance_size = sizeof(Chardev),
 490     .instance_init = char_init,
 491     .instance_finalize = char_finalize,
 492     .abstract = true,
 493     .class_size = sizeof(ChardevClass),
 494     .class_init = char_class_init,
 495 };
 496
 497 /**
 498  * Called after processing of default and command-line-specified
 499  * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
 500  * to a mux chardev. This is done here to ensure that
 501  * output/prompts/banners are only displayed for the FE that has
 502  * focus when initial command-line processing/machine init is
 503  * completed.
 504  *
 505  * After this point, any new FE attached to any new or existing
 506  * mux will receive CHR_EVENT_OPENED notifications for the BE
 507  * immediately.
 508  */
 509 static void muxes_realize_done(Notifier *notifier, void *unused)
 510 {
 511     Chardev *chr;
 512
 513     QTAILQ_FOREACH(chr, &chardevs, next) {
 514         if (CHARDEV_IS_MUX(chr)) {
 515             MuxChardev *d = MUX_CHARDEV(chr);
 516             int i;
 517
 518             /* send OPENED to all already-attached FEs */
 519             for (i = 0; i < d->mux_cnt; i++) {
 520                 mux_chr_send_event(d, i, CHR_EVENT_OPENED);
 521             }
 522             /* mark mux as OPENED so any new FEs will immediately receive
 523              * OPENED event
 524              */
 525             qemu_chr_be_generic_open(chr);
 526         }
 527     }
 528     muxes_realized = true;
 529 }
 530
 531 static Notifier muxes_realize_notify = {
 532     .notify = muxes_realize_done,
 533 };
 534
 535 Chardev *qemu_chr_fe_get_driver(CharBackend *be)
 536 {
 537     return be->chr;
 538 }
 539
 540 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
 541 {
 542     int tag = 0;
 543
 544     if (CHARDEV_IS_MUX(s)) {
 545         MuxChardev *d = MUX_CHARDEV(s);
 546
 547         if (d->mux_cnt >= MAX_MUX) {
 548             goto unavailable;
 549         }
 550
 551         d->backends[d->mux_cnt] = b;
 552         tag = d->mux_cnt++;
 553     } else if (s->be) {
 554         goto unavailable;
 555     } else {
 556         s->be = b;
 557     }
 558
 559     b->fe_open = false;
 560     b->tag = tag;
 561     b->chr = s;
 562     return true;
 563
 564 unavailable:
 565     error_setg(errp, QERR_DEVICE_IN_USE, s->label);
 566     return false;
 567 }
 568
 569 static bool qemu_chr_is_busy(Chardev *s)
 570 {
 571     if (CHARDEV_IS_MUX(s)) {
 572         MuxChardev *d = MUX_CHARDEV(s);
 573         return d->mux_cnt >= 0;
 574     } else {
 575         return s->be != NULL;
 576     }
 577 }
 578
 579 void qemu_chr_fe_deinit(CharBackend *b)
 580 {
 581     assert(b);
 582
 583     if (b->chr) {
 584         qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
 585         if (b->chr->be == b) {
 586             b->chr->be = NULL;
 587         }
 588         if (CHARDEV_IS_MUX(b->chr)) {
 589             MuxChardev *d = MUX_CHARDEV(b->chr);
 590             d->backends[b->tag] = NULL;
 591         }
 592         b->chr = NULL;
 593     }
 594 }
 595
 596 void qemu_chr_fe_set_handlers(CharBackend *b,
 597                               IOCanReadHandler *fd_can_read,
 598                               IOReadHandler *fd_read,
 599                               IOEventHandler *fd_event,
 600                               void *opaque,
 601                               GMainContext *context,
 602                               bool set_open)
 603 {
 604     Chardev *s;
 605     ChardevClass *cc;
 606     int fe_open;
 607
 608     s = b->chr;
 609     if (!s) {
 610         return;
 611     }
 612
 613     cc = CHARDEV_GET_CLASS(s);
 614     if (!opaque && !fd_can_read && !fd_read && !fd_event) {
 615         fe_open = 0;
 616         remove_fd_in_watch(s);
 617     } else {
 618         fe_open = 1;
 619     }
 620     b->chr_can_read = fd_can_read;
 621     b->chr_read = fd_read;
 622     b->chr_event = fd_event;
 623     b->opaque = opaque;
 624     if (cc->chr_update_read_handler) {
 625         cc->chr_update_read_handler(s, context);
 626     }
 627
 628     if (set_open) {
 629         qemu_chr_fe_set_open(b, fe_open);
 630     }
 631
 632     if (fe_open) {
 633         qemu_chr_fe_take_focus(b);
 634         /* We're connecting to an already opened device, so let's make sure we
 635            also get the open event */
 636         if (s->be_open) {
 637             qemu_chr_be_generic_open(s);
 638         }
 639     }
 640
 641     if (CHARDEV_IS_MUX(s)) {
 642         mux_chr_set_handlers(s, context);
 643     }
 644 }
 645
 646 void qemu_chr_fe_take_focus(CharBackend *b)
 647 {
 648     if (!b->chr) {
 649         return;
 650     }
 651
 652     if (CHARDEV_IS_MUX(b->chr)) {
 653         mux_set_focus(b->chr, b->tag);
 654     }
 655 }
 656
 657 #ifndef _WIN32
 658 static void qemu_chr_open_pipe(Chardev *chr,
 659                                ChardevBackend *backend,
 660                                bool *be_opened,
 661                                Error **errp)
 662 {
 663     ChardevHostdev *opts = backend->u.pipe.data;
 664     int fd_in, fd_out;
 665     char *filename_in;
 666     char *filename_out;
 667     const char *filename = opts->device;
 668
 669     filename_in = g_strdup_printf("%s.in", filename);
 670     filename_out = g_strdup_printf("%s.out", filename);
 671     TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
 672     TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
 673     g_free(filename_in);
 674     g_free(filename_out);
 675     if (fd_in < 0 || fd_out < 0) {
 676         if (fd_in >= 0)
 677             close(fd_in);
 678         if (fd_out >= 0)
 679             close(fd_out);
 680         TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
 681         if (fd_in < 0) {
 682             error_setg_file_open(errp, errno, filename);
 683             return;
 684         }
 685     }
 686     qemu_chr_open_fd(chr, fd_in, fd_out);
 687 }
 688
 689 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 690     || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
 691     || defined(__GLIBC__)
 692
 693 #define HAVE_CHARDEV_SERIAL 1
 694 #define HAVE_CHARDEV_PTY 1
 695
 696 typedef struct {
 697     Chardev parent;
 698     QIOChannel *ioc;
 699     int read_bytes;
 700
 701     /* Protected by the Chardev chr_write_lock.  */
 702     int connected;
 703     guint timer_tag;
 704     guint open_tag;
 705 } PtyChardev;
 706
 707 #define PTY_CHARDEV(obj) OBJECT_CHECK(PtyChardev, (obj), TYPE_CHARDEV_PTY)
 708
 709 static void pty_chr_update_read_handler_locked(Chardev *chr);
 710 static void pty_chr_state(Chardev *chr, int connected);
 711
 712 static gboolean pty_chr_timer(gpointer opaque)
 713 {
 714     struct Chardev *chr = CHARDEV(opaque);
 715     PtyChardev *s = PTY_CHARDEV(opaque);
 716
 717     qemu_mutex_lock(&chr->chr_write_lock);
 718     s->timer_tag = 0;
 719     s->open_tag = 0;
 720     if (!s->connected) {
 721         /* Next poll ... */
 722         pty_chr_update_read_handler_locked(chr);
 723     }
 724     qemu_mutex_unlock(&chr->chr_write_lock);
 725     return FALSE;
 726 }
 727
 728 /* Called with chr_write_lock held.  */
 729 static void pty_chr_rearm_timer(Chardev *chr, int ms)
 730 {
 731     PtyChardev *s = PTY_CHARDEV(chr);
 732     char *name;
 733
 734     if (s->timer_tag) {
 735         g_source_remove(s->timer_tag);
 736         s->timer_tag = 0;
 737     }
 738
 739     if (ms == 1000) {
 740         name = g_strdup_printf("pty-timer-secs-%s", chr->label);
 741         s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr);
 742     } else {
 743         name = g_strdup_printf("pty-timer-ms-%s", chr->label);
 744         s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr);
 745     }
 746     g_source_set_name_by_id(s->timer_tag, name);
 747     g_free(name);
 748 }
 749
 750 /* Called with chr_write_lock held.  */
 751 static void pty_chr_update_read_handler_locked(Chardev *chr)
 752 {
 753     PtyChardev *s = PTY_CHARDEV(chr);
 754     GPollFD pfd;
 755     int rc;
 756     QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc);
 757
 758     pfd.fd = fioc->fd;
 759     pfd.events = G_IO_OUT;
 760     pfd.revents = 0;
 761     do {
 762         rc = g_poll(&pfd, 1, 0);
 763     } while (rc == -1 && errno == EINTR);
 764     assert(rc >= 0);
 765
 766     if (pfd.revents & G_IO_HUP) {
 767         pty_chr_state(chr, 0);
 768     } else {
 769         pty_chr_state(chr, 1);
 770     }
 771 }
 772
 773 static void pty_chr_update_read_handler(Chardev *chr,
 774                                         GMainContext *context)
 775 {
 776     qemu_mutex_lock(&chr->chr_write_lock);
 777     pty_chr_update_read_handler_locked(chr);
 778     qemu_mutex_unlock(&chr->chr_write_lock);
 779 }
 780
 781 /* Called with chr_write_lock held.  */
 782 static int char_pty_chr_write(Chardev *chr, const uint8_t *buf, int len)
 783 {
 784     PtyChardev *s = PTY_CHARDEV(chr);
 785
 786     if (!s->connected) {
 787         /* guest sends data, check for (re-)connect */
 788         pty_chr_update_read_handler_locked(chr);
 789         if (!s->connected) {
 790             return 0;
 791         }
 792     }
 793     return io_channel_send(s->ioc, buf, len);
 794 }
 795
 796 static GSource *pty_chr_add_watch(Chardev *chr, GIOCondition cond)
 797 {
 798     PtyChardev *s = PTY_CHARDEV(chr);
 799     if (!s->connected) {
 800         return NULL;
 801     }
 802     return qio_channel_create_watch(s->ioc, cond);
 803 }
 804
 805 static int pty_chr_read_poll(void *opaque)
 806 {
 807     Chardev *chr = CHARDEV(opaque);
 808     PtyChardev *s = PTY_CHARDEV(opaque);
 809
 810     s->read_bytes = qemu_chr_be_can_write(chr);
 811     return s->read_bytes;
 812 }
 813
 814 static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
 815 {
 816     Chardev *chr = CHARDEV(opaque);
 817     PtyChardev *s = PTY_CHARDEV(opaque);
 818     gsize len;
 819     uint8_t buf[CHR_READ_BUF_LEN];
 820     ssize_t ret;
 821
 822     len = sizeof(buf);
 823     if (len > s->read_bytes)
 824         len = s->read_bytes;
 825     if (len == 0) {
 826         return TRUE;
 827     }
 828     ret = qio_channel_read(s->ioc, (char *)buf, len, NULL);
 829     if (ret <= 0) {
 830         pty_chr_state(chr, 0);
 831         return FALSE;
 832     } else {
 833         pty_chr_state(chr, 1);
 834         qemu_chr_be_write(chr, buf, ret);
 835     }
 836     return TRUE;
 837 }
 838
 839 static gboolean qemu_chr_be_generic_open_func(gpointer opaque)
 840 {
 841     Chardev *chr = CHARDEV(opaque);
 842     PtyChardev *s = PTY_CHARDEV(opaque);
 843
 844     s->open_tag = 0;
 845     qemu_chr_be_generic_open(chr);
 846     return FALSE;
 847 }
 848
 849 /* Called with chr_write_lock held.  */
 850 static void pty_chr_state(Chardev *chr, int connected)
 851 {
 852     PtyChardev *s = PTY_CHARDEV(chr);
 853
 854     if (!connected) {
 855         if (s->open_tag) {
 856             g_source_remove(s->open_tag);
 857             s->open_tag = 0;
 858         }
 859         remove_fd_in_watch(chr);
 860         s->connected = 0;
 861         /* (re-)connect poll interval for idle guests: once per second.
 862          * We check more frequently in case the guests sends data to
 863          * the virtual device linked to our pty. */
 864         pty_chr_rearm_timer(chr, 1000);
 865     } else {
 866         if (s->timer_tag) {
 867             g_source_remove(s->timer_tag);
 868             s->timer_tag = 0;
 869         }
 870         if (!s->connected) {
 871             g_assert(s->open_tag == 0);
 872             s->connected = 1;
 873             s->open_tag = g_idle_add(qemu_chr_be_generic_open_func, chr);
 874         }
 875         if (!chr->fd_in_tag) {
 876             chr->fd_in_tag = io_add_watch_poll(chr, s->ioc,
 877                                                pty_chr_read_poll,
 878                                                pty_chr_read,
 879                                                chr, NULL);
 880         }
 881     }
 882 }
 883
 884 static void char_pty_finalize(Object *obj)
 885 {
 886     Chardev *chr = CHARDEV(obj);
 887     PtyChardev *s = PTY_CHARDEV(obj);
 888
 889     qemu_mutex_lock(&chr->chr_write_lock);
 890     pty_chr_state(chr, 0);
 891     object_unref(OBJECT(s->ioc));
 892     if (s->timer_tag) {
 893         g_source_remove(s->timer_tag);
 894         s->timer_tag = 0;
 895     }
 896     qemu_mutex_unlock(&chr->chr_write_lock);
 897     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 898 }
 899
 900 static void char_pty_open(Chardev *chr,
 901                           ChardevBackend *backend,
 902                           bool *be_opened,
 903                           Error **errp)
 904 {
 905     PtyChardev *s;
 906     int master_fd, slave_fd;
 907     char pty_name[PATH_MAX];
 908     char *name;
 909
 910     master_fd = qemu_openpty_raw(&slave_fd, pty_name);
 911     if (master_fd < 0) {
 912         error_setg_errno(errp, errno, "Failed to create PTY");
 913         return;
 914     }
 915
 916     close(slave_fd);
 917     qemu_set_nonblock(master_fd);
 918
 919     chr->filename = g_strdup_printf("pty:%s", pty_name);
 920     error_report("char device redirected to %s (label %s)",
 921                  pty_name, chr->label);
 922
 923     s = PTY_CHARDEV(chr);
 924     s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd));
 925     name = g_strdup_printf("chardev-pty-%s", chr->label);
 926     qio_channel_set_name(QIO_CHANNEL(s->ioc), name);
 927     g_free(name);
 928     s->timer_tag = 0;
 929     *be_opened = false;
 930 }
 931
 932 static void char_pty_class_init(ObjectClass *oc, void *data)
 933 {
 934     ChardevClass *cc = CHARDEV_CLASS(oc);
 935
 936     cc->open = char_pty_open;
 937     cc->chr_write = char_pty_chr_write;
 938     cc->chr_update_read_handler = pty_chr_update_read_handler;
 939     cc->chr_add_watch = pty_chr_add_watch;
 940 }
 941
 942 static const TypeInfo char_pty_type_info = {
 943     .name = TYPE_CHARDEV_PTY,
 944     .parent = TYPE_CHARDEV,
 945     .instance_size = sizeof(PtyChardev),
 946     .instance_finalize = char_pty_finalize,
 947     .class_init = char_pty_class_init,
 948 };
 949
 950 static void tty_serial_init(int fd, int speed,
 951                             int parity, int data_bits, int stop_bits)
 952 {
 953     struct termios tty;
 954     speed_t spd;
 955
 956 #if 0
 957     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
 958            speed, parity, data_bits, stop_bits);
 959 #endif
 960     tcgetattr (fd, &tty);
 961
 962 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
 963     speed = speed * 10 / 11;
 964     do {
 965         check_speed(50);
 966         check_speed(75);
 967         check_speed(110);
 968         check_speed(134);
 969         check_speed(150);
 970         check_speed(200);
 971         check_speed(300);
 972         check_speed(600);
 973         check_speed(1200);
 974         check_speed(1800);
 975         check_speed(2400);
 976         check_speed(4800);
 977         check_speed(9600);
 978         check_speed(19200);
 979         check_speed(38400);
 980         /* Non-Posix values follow. They may be unsupported on some systems. */
 981         check_speed(57600);
 982         check_speed(115200);
 983 #ifdef B230400
 984         check_speed(230400);
 985 #endif
 986 #ifdef B460800
 987         check_speed(460800);
 988 #endif
 989 #ifdef B500000
 990         check_speed(500000);
 991 #endif
 992 #ifdef B576000
 993         check_speed(576000);
 994 #endif
 995 #ifdef B921600
 996         check_speed(921600);
 997 #endif
 998 #ifdef B1000000
 999         check_speed(1000000);
1000 #endif
1001 #ifdef B1152000
1002         check_speed(1152000);
1003 #endif
1004 #ifdef B1500000
1005         check_speed(1500000);
1006 #endif
1007 #ifdef B2000000
1008         check_speed(2000000);
1009 #endif
1010 #ifdef B2500000
1011         check_speed(2500000);
1012 #endif
1013 #ifdef B3000000
1014         check_speed(3000000);
1015 #endif
1016 #ifdef B3500000
1017         check_speed(3500000);
1018 #endif
1019 #ifdef B4000000
1020         check_speed(4000000);
1021 #endif
1022         spd = B115200;
1023     } while (0);
1024
1025     cfsetispeed(&tty, spd);
1026     cfsetospeed(&tty, spd);
1027
1028     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1029                           |INLCR|IGNCR|ICRNL|IXON);
1030     tty.c_oflag |= OPOST;
1031     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1032     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1033     switch(data_bits) {
1034     default:
1035     case 8:
1036         tty.c_cflag |= CS8;
1037         break;
1038     case 7:
1039         tty.c_cflag |= CS7;
1040         break;
1041     case 6:
1042         tty.c_cflag |= CS6;
1043         break;
1044     case 5:
1045         tty.c_cflag |= CS5;
1046         break;
1047     }
1048     switch(parity) {
1049     default:
1050     case 'N':
1051         break;
1052     case 'E':
1053         tty.c_cflag |= PARENB;
1054         break;
1055     case 'O':
1056         tty.c_cflag |= PARENB | PARODD;
1057         break;
1058     }
1059     if (stop_bits == 2)
1060         tty.c_cflag |= CSTOPB;
1061
1062     tcsetattr (fd, TCSANOW, &tty);
1063 }
1064
1065 static int tty_serial_ioctl(Chardev *chr, int cmd, void *arg)
1066 {
1067     FDChardev *s = FD_CHARDEV(chr);
1068     QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc_in);
1069
1070     switch(cmd) {
1071     case CHR_IOCTL_SERIAL_SET_PARAMS:
1072         {
1073             QEMUSerialSetParams *ssp = arg;
1074             tty_serial_init(fioc->fd,
1075                             ssp->speed, ssp->parity,
1076                             ssp->data_bits, ssp->stop_bits);
1077         }
1078         break;
1079     case CHR_IOCTL_SERIAL_SET_BREAK:
1080         {
1081             int enable = *(int *)arg;
1082             if (enable) {
1083                 tcsendbreak(fioc->fd, 1);
1084             }
1085         }
1086         break;
1087     case CHR_IOCTL_SERIAL_GET_TIOCM:
1088         {
1089             int sarg = 0;
1090             int *targ = (int *)arg;
1091             ioctl(fioc->fd, TIOCMGET, &sarg);
1092             *targ = 0;
1093             if (sarg & TIOCM_CTS)
1094                 *targ |= CHR_TIOCM_CTS;
1095             if (sarg & TIOCM_CAR)
1096                 *targ |= CHR_TIOCM_CAR;
1097             if (sarg & TIOCM_DSR)
1098                 *targ |= CHR_TIOCM_DSR;
1099             if (sarg & TIOCM_RI)
1100                 *targ |= CHR_TIOCM_RI;
1101             if (sarg & TIOCM_DTR)
1102                 *targ |= CHR_TIOCM_DTR;
1103             if (sarg & TIOCM_RTS)
1104                 *targ |= CHR_TIOCM_RTS;
1105         }
1106         break;
1107     case CHR_IOCTL_SERIAL_SET_TIOCM:
1108         {
1109             int sarg = *(int *)arg;
1110             int targ = 0;
1111             ioctl(fioc->fd, TIOCMGET, &targ);
1112             targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
1113                      | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
1114             if (sarg & CHR_TIOCM_CTS)
1115                 targ |= TIOCM_CTS;
1116             if (sarg & CHR_TIOCM_CAR)
1117                 targ |= TIOCM_CAR;
1118             if (sarg & CHR_TIOCM_DSR)
1119                 targ |= TIOCM_DSR;
1120             if (sarg & CHR_TIOCM_RI)
1121                 targ |= TIOCM_RI;
1122             if (sarg & CHR_TIOCM_DTR)
1123                 targ |= TIOCM_DTR;
1124             if (sarg & CHR_TIOCM_RTS)
1125                 targ |= TIOCM_RTS;
1126             ioctl(fioc->fd, TIOCMSET, &targ);
1127         }
1128         break;
1129     default:
1130         return -ENOTSUP;
1131     }
1132     return 0;
1133 }
1134 #endif /* __linux__ || __sun__ */
1135
1136 #if defined(__linux__)
1137
1138 #define HAVE_CHARDEV_PARPORT 1
1139
1140 typedef struct {
1141     Chardev parent;
1142     int fd;
1143     int mode;
1144 } ParallelChardev;
1145
1146 #define PARALLEL_CHARDEV(obj) \
1147     OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL)
1148
1149 static int pp_hw_mode(ParallelChardev *s, uint16_t mode)
1150 {
1151     if (s->mode != mode) {
1152         int m = mode;
1153         if (ioctl(s->fd, PPSETMODE, &m) < 0)
1154             return 0;
1155         s->mode = mode;
1156     }
1157     return 1;
1158 }
1159
1160 static int pp_ioctl(Chardev *chr, int cmd, void *arg)
1161 {
1162     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
1163     int fd = drv->fd;
1164     uint8_t b;
1165
1166     switch(cmd) {
1167     case CHR_IOCTL_PP_READ_DATA:
1168         if (ioctl(fd, PPRDATA, &b) < 0)
1169             return -ENOTSUP;
1170         *(uint8_t *)arg = b;
1171         break;
1172     case CHR_IOCTL_PP_WRITE_DATA:
1173         b = *(uint8_t *)arg;
1174         if (ioctl(fd, PPWDATA, &b) < 0)
1175             return -ENOTSUP;
1176         break;
1177     case CHR_IOCTL_PP_READ_CONTROL:
1178         if (ioctl(fd, PPRCONTROL, &b) < 0)
1179             return -ENOTSUP;
1180         /* Linux gives only the lowest bits, and no way to know data
1181            direction! For better compatibility set the fixed upper
1182            bits. */
1183         *(uint8_t *)arg = b | 0xc0;
1184         break;
1185     case CHR_IOCTL_PP_WRITE_CONTROL:
1186         b = *(uint8_t *)arg;
1187         if (ioctl(fd, PPWCONTROL, &b) < 0)
1188             return -ENOTSUP;
1189         break;
1190     case CHR_IOCTL_PP_READ_STATUS:
1191         if (ioctl(fd, PPRSTATUS, &b) < 0)
1192             return -ENOTSUP;
1193         *(uint8_t *)arg = b;
1194         break;
1195     case CHR_IOCTL_PP_DATA_DIR:
1196         if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
1197             return -ENOTSUP;
1198         break;
1199     case CHR_IOCTL_PP_EPP_READ_ADDR:
1200         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1201             struct ParallelIOArg *parg = arg;
1202             int n = read(fd, parg->buffer, parg->count);
1203             if (n != parg->count) {
1204                 return -EIO;
1205             }
1206         }
1207         break;
1208     case CHR_IOCTL_PP_EPP_READ:
1209         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1210             struct ParallelIOArg *parg = arg;
1211             int n = read(fd, parg->buffer, parg->count);
1212             if (n != parg->count) {
1213                 return -EIO;
1214             }
1215         }
1216         break;
1217     case CHR_IOCTL_PP_EPP_WRITE_ADDR:
1218         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1219             struct ParallelIOArg *parg = arg;
1220             int n = write(fd, parg->buffer, parg->count);
1221             if (n != parg->count) {
1222                 return -EIO;
1223             }
1224         }
1225         break;
1226     case CHR_IOCTL_PP_EPP_WRITE:
1227         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1228             struct ParallelIOArg *parg = arg;
1229             int n = write(fd, parg->buffer, parg->count);
1230             if (n != parg->count) {
1231                 return -EIO;
1232             }
1233         }
1234         break;
1235     default:
1236         return -ENOTSUP;
1237     }
1238     return 0;
1239 }
1240
1241 static void qemu_chr_open_pp_fd(Chardev *chr,
1242                                 int fd,
1243                                 bool *be_opened,
1244                                 Error **errp)
1245 {
1246     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
1247
1248     if (ioctl(fd, PPCLAIM) < 0) {
1249         error_setg_errno(errp, errno, "not a parallel port");
1250         close(fd);
1251         return;
1252     }
1253
1254     drv->fd = fd;
1255     drv->mode = IEEE1284_MODE_COMPAT;
1256 }
1257 #endif /* __linux__ */
1258
1259 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1260
1261 #define HAVE_CHARDEV_PARPORT 1
1262
1263 typedef struct {
1264     Chardev parent;
1265     int fd;
1266 } ParallelChardev;
1267
1268 #define PARALLEL_CHARDEV(obj)                                   \
1269     OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL)
1270
1271 static int pp_ioctl(Chardev *chr, int cmd, void *arg)
1272 {
1273     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
1274     uint8_t b;
1275
1276     switch (cmd) {
1277     case CHR_IOCTL_PP_READ_DATA:
1278         if (ioctl(drv->fd, PPIGDATA, &b) < 0) {
1279             return -ENOTSUP;
1280         }
1281         *(uint8_t *)arg = b;
1282         break;
1283     case CHR_IOCTL_PP_WRITE_DATA:
1284         b = *(uint8_t *)arg;
1285         if (ioctl(drv->fd, PPISDATA, &b) < 0) {
1286             return -ENOTSUP;
1287         }
1288         break;
1289     case CHR_IOCTL_PP_READ_CONTROL:
1290         if (ioctl(drv->fd, PPIGCTRL, &b) < 0) {
1291             return -ENOTSUP;
1292         }
1293         *(uint8_t *)arg = b;
1294         break;
1295     case CHR_IOCTL_PP_WRITE_CONTROL:
1296         b = *(uint8_t *)arg;
1297         if (ioctl(drv->fd, PPISCTRL, &b) < 0) {
1298             return -ENOTSUP;
1299         }
1300         break;
1301     case CHR_IOCTL_PP_READ_STATUS:
1302         if (ioctl(drv->fd, PPIGSTATUS, &b) < 0) {
1303             return -ENOTSUP;
1304         }
1305         *(uint8_t *)arg = b;
1306         break;
1307     default:
1308         return -ENOTSUP;
1309     }
1310     return 0;
1311 }
1312
1313 static void qemu_chr_open_pp_fd(Chardev *chr,
1314                                 int fd,
1315                                 bool *be_opened,
1316                                 Error **errp)
1317 {
1318     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
1319     drv->fd = fd;
1320     *be_opened = false;
1321 }
1322 #endif
1323
1324 #else /* _WIN32 */
1325
1326 #define HAVE_CHARDEV_SERIAL 1
1327
1328 #define MAXCONNECT 1
1329 #define NTIMEOUT 5000
1330
1331 static int win_chr_pipe_init(Chardev *chr, const char *filename,
1332                              Error **errp)
1333 {
1334     WinChardev *s = WIN_CHARDEV(chr);
1335     OVERLAPPED ov;
1336     int ret;
1337     DWORD size;
1338     char *openname;
1339
1340     s->fpipe = TRUE;
1341
1342     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1343     if (!s->hsend) {
1344         error_setg(errp, "Failed CreateEvent");
1345         goto fail;
1346     }
1347     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1348     if (!s->hrecv) {
1349         error_setg(errp, "Failed CreateEvent");
1350         goto fail;
1351     }
1352
1353     openname = g_strdup_printf("\\\\.\\pipe\\%s", filename);
1354     s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
1355                               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
1356                               PIPE_WAIT,
1357                               MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
1358     g_free(openname);
1359     if (s->hcom == INVALID_HANDLE_VALUE) {
1360         error_setg(errp, "Failed CreateNamedPipe (%lu)", GetLastError());
1361         s->hcom = NULL;
1362         goto fail;
1363     }
1364
1365     ZeroMemory(&ov, sizeof(ov));
1366     ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1367     ret = ConnectNamedPipe(s->hcom, &ov);
1368     if (ret) {
1369         error_setg(errp, "Failed ConnectNamedPipe");
1370         goto fail;
1371     }
1372
1373     ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
1374     if (!ret) {
1375         error_setg(errp, "Failed GetOverlappedResult");
1376         if (ov.hEvent) {
1377             CloseHandle(ov.hEvent);
1378             ov.hEvent = NULL;
1379         }
1380         goto fail;
1381     }
1382
1383     if (ov.hEvent) {
1384         CloseHandle(ov.hEvent);
1385         ov.hEvent = NULL;
1386     }
1387     qemu_add_polling_cb(win_chr_pipe_poll, chr);
1388     return 0;
1389
1390  fail:
1391     return -1;
1392 }
1393
1394
1395 static void qemu_chr_open_pipe(Chardev *chr,
1396                                ChardevBackend *backend,
1397                                bool *be_opened,
1398                                Error **errp)
1399 {
1400     ChardevHostdev *opts = backend->u.pipe.data;
1401     const char *filename = opts->device;
1402
1403     if (win_chr_pipe_init(chr, filename, errp) < 0) {
1404         return;
1405     }
1406 }
1407
1408 static void qemu_chr_open_win_con(Chardev *chr,
1409                                   ChardevBackend *backend,
1410                                   bool *be_opened,
1411                                   Error **errp)
1412 {
1413     qemu_chr_open_win_file(chr, GetStdHandle(STD_OUTPUT_HANDLE));
1414 }
1415
1416 static void char_console_class_init(ObjectClass *oc, void *data)
1417 {
1418     ChardevClass *cc = CHARDEV_CLASS(oc);
1419
1420     cc->open = qemu_chr_open_win_con;
1421 }
1422
1423 static const TypeInfo char_console_type_info = {
1424     .name = TYPE_CHARDEV_CONSOLE,
1425     .parent = TYPE_CHARDEV_WIN,
1426     .class_init = char_console_class_init,
1427 };
1428
1429 #endif /* !_WIN32 */
1430
1431 int qemu_chr_wait_connected(Chardev *chr, Error **errp)
1432 {
1433     ChardevClass *cc = CHARDEV_GET_CLASS(chr);
1434
1435     if (cc->chr_wait_connected) {
1436         return cc->chr_wait_connected(chr, errp);
1437     }
1438
1439     return 0;
1440 }
1441
1442 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
1443 {
1444     if (!be->chr) {
1445         error_setg(errp, "missing associated backend");
1446         return -1;
1447     }
1448
1449     return qemu_chr_wait_connected(be->chr, errp);
1450 }
1451
1452 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
1453 {
1454     char host[65], port[33], width[8], height[8];
1455     int pos;
1456     const char *p;
1457     QemuOpts *opts;
1458     Error *local_err = NULL;
1459
1460     opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
1461     if (local_err) {
1462         error_report_err(local_err);
1463         return NULL;
1464     }
1465
1466     if (strstart(filename, "mon:", &p)) {
1467         filename = p;
1468         qemu_opt_set(opts, "mux", "on", &error_abort);
1469         if (strcmp(filename, "stdio") == 0) {
1470             /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
1471              * but pass it to the guest.  Handle this only for compat syntax,
1472              * for -chardev syntax we have special option for this.
1473              * This is what -nographic did, redirecting+muxing serial+monitor
1474              * to stdio causing Ctrl+C to be passed to guest. */
1475             qemu_opt_set(opts, "signal", "off", &error_abort);
1476         }
1477     }
1478
1479     if (strcmp(filename, "null")    == 0 ||
1480         strcmp(filename, "pty")     == 0 ||
1481         strcmp(filename, "msmouse") == 0 ||
1482         strcmp(filename, "braille") == 0 ||
1483         strcmp(filename, "testdev") == 0 ||
1484         strcmp(filename, "stdio")   == 0) {
1485         qemu_opt_set(opts, "backend", filename, &error_abort);
1486         return opts;
1487     }
1488     if (strstart(filename, "vc", &p)) {
1489         qemu_opt_set(opts, "backend", "vc", &error_abort);
1490         if (*p == ':') {
1491             if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
1492                 /* pixels */
1493                 qemu_opt_set(opts, "width", width, &error_abort);
1494                 qemu_opt_set(opts, "height", height, &error_abort);
1495             } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
1496                 /* chars */
1497                 qemu_opt_set(opts, "cols", width, &error_abort);
1498                 qemu_opt_set(opts, "rows", height, &error_abort);
1499             } else {
1500                 goto fail;
1501             }
1502         }
1503         return opts;
1504     }
1505     if (strcmp(filename, "con:") == 0) {
1506         qemu_opt_set(opts, "backend", "console", &error_abort);
1507         return opts;
1508     }
1509     if (strstart(filename, "COM", NULL)) {
1510         qemu_opt_set(opts, "backend", "serial", &error_abort);
1511         qemu_opt_set(opts, "path", filename, &error_abort);
1512         return opts;
1513     }
1514     if (strstart(filename, "file:", &p)) {
1515         qemu_opt_set(opts, "backend", "file", &error_abort);
1516         qemu_opt_set(opts, "path", p, &error_abort);
1517         return opts;
1518     }
1519     if (strstart(filename, "pipe:", &p)) {
1520         qemu_opt_set(opts, "backend", "pipe", &error_abort);
1521         qemu_opt_set(opts, "path", p, &error_abort);
1522         return opts;
1523     }
1524     if (strstart(filename, "tcp:", &p) ||
1525         strstart(filename, "telnet:", &p)) {
1526         if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
1527             host[0] = 0;
1528             if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
1529                 goto fail;
1530         }
1531         qemu_opt_set(opts, "backend", "socket", &error_abort);
1532         qemu_opt_set(opts, "host", host, &error_abort);
1533         qemu_opt_set(opts, "port", port, &error_abort);
1534         if (p[pos] == ',') {
1535             qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
1536             if (local_err) {
1537                 error_report_err(local_err);
1538                 goto fail;
1539             }
1540         }
1541         if (strstart(filename, "telnet:", &p))
1542             qemu_opt_set(opts, "telnet", "on", &error_abort);
1543         return opts;
1544     }
1545     if (strstart(filename, "udp:", &p)) {
1546         qemu_opt_set(opts, "backend", "udp", &error_abort);
1547         if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
1548             host[0] = 0;
1549             if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
1550                 goto fail;
1551             }
1552         }
1553         qemu_opt_set(opts, "host", host, &error_abort);
1554         qemu_opt_set(opts, "port", port, &error_abort);
1555         if (p[pos] == '@') {
1556             p += pos + 1;
1557             if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
1558                 host[0] = 0;
1559                 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
1560                     goto fail;
1561                 }
1562             }
1563             qemu_opt_set(opts, "localaddr", host, &error_abort);
1564             qemu_opt_set(opts, "localport", port, &error_abort);
1565         }
1566         return opts;
1567     }
1568     if (strstart(filename, "unix:", &p)) {
1569         qemu_opt_set(opts, "backend", "socket", &error_abort);
1570         qemu_opts_do_parse(opts, p, "path", &local_err);
1571         if (local_err) {
1572             error_report_err(local_err);
1573             goto fail;
1574         }
1575         return opts;
1576     }
1577     if (strstart(filename, "/dev/parport", NULL) ||
1578         strstart(filename, "/dev/ppi", NULL)) {
1579         qemu_opt_set(opts, "backend", "parport", &error_abort);
1580         qemu_opt_set(opts, "path", filename, &error_abort);
1581         return opts;
1582     }
1583     if (strstart(filename, "/dev/", NULL)) {
1584         qemu_opt_set(opts, "backend", "tty", &error_abort);
1585         qemu_opt_set(opts, "path", filename, &error_abort);
1586         return opts;
1587     }
1588
1589 fail:
1590     qemu_opts_del(opts);
1591     return NULL;
1592 }
1593
1594 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
1595 {
1596     const char *logfile = qemu_opt_get(opts, "logfile");
1597
1598     backend->has_logfile = logfile != NULL;
1599     backend->logfile = logfile ? g_strdup(logfile) : NULL;
1600
1601     backend->has_logappend = true;
1602     backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
1603 }
1604
1605 #ifdef HAVE_CHARDEV_SERIAL
1606 static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend,
1607                                   Error **errp)
1608 {
1609     const char *device = qemu_opt_get(opts, "path");
1610     ChardevHostdev *serial;
1611
1612     backend->type = CHARDEV_BACKEND_KIND_SERIAL;
1613     if (device == NULL) {
1614         error_setg(errp, "chardev: serial/tty: no device path given");
1615         return;
1616     }
1617     serial = backend->u.serial.data = g_new0(ChardevHostdev, 1);
1618     qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(serial));
1619     serial->device = g_strdup(device);
1620 }
1621 #endif
1622
1623 #ifdef HAVE_CHARDEV_PARPORT
1624 static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend,
1625                                     Error **errp)
1626 {
1627     const char *device = qemu_opt_get(opts, "path");
1628     ChardevHostdev *parallel;
1629
1630     backend->type = CHARDEV_BACKEND_KIND_PARALLEL;
1631     if (device == NULL) {
1632         error_setg(errp, "chardev: parallel: no device path given");
1633         return;
1634     }
1635     parallel = backend->u.parallel.data = g_new0(ChardevHostdev, 1);
1636     qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(parallel));
1637     parallel->device = g_strdup(device);
1638 }
1639 #endif
1640
1641 static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend,
1642                                 Error **errp)
1643 {
1644     const char *device = qemu_opt_get(opts, "path");
1645     ChardevHostdev *dev;
1646
1647     backend->type = CHARDEV_BACKEND_KIND_PIPE;
1648     if (device == NULL) {
1649         error_setg(errp, "chardev: pipe: no device path given");
1650         return;
1651     }
1652     dev = backend->u.pipe.data = g_new0(ChardevHostdev, 1);
1653     qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(dev));
1654     dev->device = g_strdup(device);
1655 }
1656
1657 static void char_pipe_class_init(ObjectClass *oc, void *data)
1658 {
1659     ChardevClass *cc = CHARDEV_CLASS(oc);
1660
1661     cc->parse = qemu_chr_parse_pipe;
1662     cc->open = qemu_chr_open_pipe;
1663 }
1664
1665 static const TypeInfo char_pipe_type_info = {
1666     .name = TYPE_CHARDEV_PIPE,
1667 #ifdef _WIN32
1668     .parent = TYPE_CHARDEV_WIN,
1669 #else
1670     .parent = TYPE_CHARDEV_FD,
1671 #endif
1672     .class_init = char_pipe_class_init,
1673 };
1674
1675 static const ChardevClass *char_get_class(const char *driver, Error **errp)
1676 {
1677     ObjectClass *oc;
1678     const ChardevClass *cc;
1679     char *typename = g_strdup_printf("chardev-%s", driver);
1680
1681     oc = object_class_by_name(typename);
1682     g_free(typename);
1683
1684     if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
1685         error_setg(errp, "'%s' is not a valid char driver name", driver);
1686         return NULL;
1687     }
1688
1689     if (object_class_is_abstract(oc)) {
1690         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
1691                    "abstract device type");
1692         return NULL;
1693     }
1694
1695     cc = CHARDEV_CLASS(oc);
1696     if (cc->internal) {
1697         error_setg(errp, "'%s' is not a valid char driver name", driver);
1698         return NULL;
1699     }
1700
1701     return cc;
1702 }
1703
1704 static Chardev *qemu_chardev_add(const char *id, const char *typename,
1705                                  ChardevBackend *backend, Error **errp)
1706 {
1707     Chardev *chr;
1708
1709     chr = qemu_chr_find(id);
1710     if (chr) {
1711         error_setg(errp, "Chardev '%s' already exists", id);
1712         return NULL;
1713     }
1714
1715     chr = qemu_chardev_new(id, typename, backend, errp);
1716     if (!chr) {
1717         return NULL;
1718     }
1719
1720     QTAILQ_INSERT_TAIL(&chardevs, chr, next);
1721     return chr;
1722 }
1723
1724 static const struct ChardevAlias {
1725     const char *typename;
1726     const char *alias;
1727 } chardev_alias_table[] = {
1728 #ifdef HAVE_CHARDEV_PARPORT
1729     { "parallel", "parport" },
1730 #endif
1731 #ifdef HAVE_CHARDEV_SERIAL
1732     { "serial", "tty" },
1733 #endif
1734 };
1735
1736 typedef struct ChadevClassFE {
1737     void (*fn)(const char *name, void *opaque);
1738     void *opaque;
1739 } ChadevClassFE;
1740
1741 static void
1742 chardev_class_foreach(ObjectClass *klass, void *opaque)
1743 {
1744     ChadevClassFE *fe = opaque;
1745
1746     assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
1747     if (CHARDEV_CLASS(klass)->internal) {
1748         return;
1749     }
1750
1751     fe->fn(object_class_get_name(klass) + 8, fe->opaque);
1752 }
1753
1754 static void
1755 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
1756 {
1757     ChadevClassFE fe = { .fn = fn, .opaque = opaque };
1758     int i;
1759
1760     object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
1761
1762     for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
1763         fn(chardev_alias_table[i].alias, opaque);
1764     }
1765 }
1766
1767 static void
1768 help_string_append(const char *name, void *opaque)
1769 {
1770     GString *str = opaque;
1771
1772     g_string_append_printf(str, "\n%s", name);
1773 }
1774
1775 Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
1776                                 Error **errp)
1777 {
1778     Error *local_err = NULL;
1779     const ChardevClass *cc;
1780     Chardev *chr;
1781     int i;
1782     ChardevBackend *backend = NULL;
1783     const char *name = qemu_opt_get(opts, "backend");
1784     const char *id = qemu_opts_id(opts);
1785     char *bid = NULL;
1786
1787     if (name == NULL) {
1788         error_setg(errp, "chardev: \"%s\" missing backend",
1789                    qemu_opts_id(opts));
1790         return NULL;
1791     }
1792
1793     if (is_help_option(name)) {
1794         GString *str = g_string_new("");
1795
1796         chardev_name_foreach(help_string_append, str);
1797
1798         error_report("Available chardev backend types: %s", str->str);
1799         g_string_free(str, true);
1800         exit(0);
1801     }
1802
1803     if (id == NULL) {
1804         error_setg(errp, "chardev: no id specified");
1805         return NULL;
1806     }
1807
1808     for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
1809         if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
1810             name = chardev_alias_table[i].typename;
1811             break;
1812         }
1813     }
1814
1815     cc = char_get_class(name, errp);
1816     if (cc == NULL) {
1817         return NULL;
1818     }
1819
1820     backend = g_new0(ChardevBackend, 1);
1821     backend->type = CHARDEV_BACKEND_KIND_NULL;
1822
1823     if (qemu_opt_get_bool(opts, "mux", 0)) {
1824         bid = g_strdup_printf("%s-base", id);
1825     }
1826
1827     chr = NULL;
1828     if (cc->parse) {
1829         cc->parse(opts, backend, &local_err);
1830         if (local_err) {
1831             error_propagate(errp, local_err);
1832             goto out;
1833         }
1834     } else {
1835         ChardevCommon *ccom = g_new0(ChardevCommon, 1);
1836         qemu_chr_parse_common(opts, ccom);
1837         backend->u.null.data = ccom; /* Any ChardevCommon member would work */
1838     }
1839
1840     chr = qemu_chardev_add(bid ? bid : id,
1841                            object_class_get_name(OBJECT_CLASS(cc)),
1842                            backend, errp);
1843     if (chr == NULL) {
1844         goto out;
1845     }
1846
1847     if (bid) {
1848         Chardev *mux;
1849         qapi_free_ChardevBackend(backend);
1850         backend = g_new0(ChardevBackend, 1);
1851         backend->type = CHARDEV_BACKEND_KIND_MUX;
1852         backend->u.mux.data = g_new0(ChardevMux, 1);
1853         backend->u.mux.data->chardev = g_strdup(bid);
1854         mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp);
1855         if (mux == NULL) {
1856             qemu_chr_delete(chr);
1857             chr = NULL;
1858             goto out;
1859         }
1860         chr = mux;
1861     }
1862
1863 out:
1864     qapi_free_ChardevBackend(backend);
1865     g_free(bid);
1866     return chr;
1867 }
1868
1869 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename)
1870 {
1871     const char *p;
1872     Chardev *chr;
1873     QemuOpts *opts;
1874     Error *err = NULL;
1875
1876     if (strstart(filename, "chardev:", &p)) {
1877         return qemu_chr_find(p);
1878     }
1879
1880     opts = qemu_chr_parse_compat(label, filename);
1881     if (!opts)
1882         return NULL;
1883
1884     chr = qemu_chr_new_from_opts(opts, &err);
1885     if (err) {
1886         error_report_err(err);
1887     }
1888     if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
1889         monitor_init(chr, MONITOR_USE_READLINE);
1890     }
1891     qemu_opts_del(opts);
1892     return chr;
1893 }
1894
1895 Chardev *qemu_chr_new(const char *label, const char *filename)
1896 {
1897     Chardev *chr;
1898     chr = qemu_chr_new_noreplay(label, filename);
1899     if (chr) {
1900         if (replay_mode != REPLAY_MODE_NONE) {
1901             qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
1902         }
1903         if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
1904             error_report("Replay: ioctl is not supported "
1905                          "for serial devices yet");
1906         }
1907         replay_register_char_driver(chr);
1908     }
1909     return chr;
1910 }
1911
1912 void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
1913 {
1914     Chardev *chr = be->chr;
1915
1916     if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
1917         CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
1918     }
1919 }
1920
1921 void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
1922 {
1923     Chardev *chr = be->chr;
1924
1925     if (!chr) {
1926         return;
1927     }
1928
1929     if (be->fe_open == fe_open) {
1930         return;
1931     }
1932     be->fe_open = fe_open;
1933     if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
1934         CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
1935     }
1936 }
1937
1938 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
1939                             GIOFunc func, void *user_data)
1940 {
1941     Chardev *s = be->chr;
1942     GSource *src;
1943     guint tag;
1944
1945     if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
1946         return 0;
1947     }
1948
1949     src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
1950     if (!src) {
1951         return 0;
1952     }
1953
1954     g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
1955     tag = g_source_attach(src, NULL);
1956     g_source_unref(src);
1957
1958     return tag;
1959 }
1960
1961 void qemu_chr_fe_disconnect(CharBackend *be)
1962 {
1963     Chardev *chr = be->chr;
1964
1965     if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
1966         CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
1967     }
1968 }
1969
1970 void qemu_chr_delete(Chardev *chr)
1971 {
1972     QTAILQ_REMOVE(&chardevs, chr, next);
1973     object_unref(OBJECT(chr));
1974 }
1975
1976 ChardevInfoList *qmp_query_chardev(Error **errp)
1977 {
1978     ChardevInfoList *chr_list = NULL;
1979     Chardev *chr;
1980
1981     QTAILQ_FOREACH(chr, &chardevs, next) {
1982         ChardevInfoList *info = g_malloc0(sizeof(*info));
1983         info->value = g_malloc0(sizeof(*info->value));
1984         info->value->label = g_strdup(chr->label);
1985         info->value->filename = g_strdup(chr->filename);
1986         info->value->frontend_open = chr->be && chr->be->fe_open;
1987
1988         info->next = chr_list;
1989         chr_list = info;
1990     }
1991
1992     return chr_list;
1993 }
1994
1995 static void
1996 qmp_prepend_backend(const char *name, void *opaque)
1997 {
1998     ChardevBackendInfoList **list = opaque;
1999     ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
2000
2001     info->value = g_malloc0(sizeof(*info->value));
2002     info->value->name = g_strdup(name);
2003     info->next = *list;
2004     *list = info;
2005 }
2006
2007 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
2008 {
2009     ChardevBackendInfoList *backend_list = NULL;
2010
2011     chardev_name_foreach(qmp_prepend_backend, &backend_list);
2012
2013     return backend_list;
2014 }
2015
2016 Chardev *qemu_chr_find(const char *name)
2017 {
2018     Chardev *chr;
2019
2020     QTAILQ_FOREACH(chr, &chardevs, next) {
2021         if (strcmp(chr->label, name) != 0)
2022             continue;
2023         return chr;
2024     }
2025     return NULL;
2026 }
2027
2028 QemuOptsList qemu_chardev_opts = {
2029     .name = "chardev",
2030     .implied_opt_name = "backend",
2031     .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
2032     .desc = {
2033         {
2034             .name = "backend",
2035             .type = QEMU_OPT_STRING,
2036         },{
2037             .name = "path",
2038             .type = QEMU_OPT_STRING,
2039         },{
2040             .name = "host",
2041             .type = QEMU_OPT_STRING,
2042         },{
2043             .name = "port",
2044             .type = QEMU_OPT_STRING,
2045         },{
2046             .name = "localaddr",
2047             .type = QEMU_OPT_STRING,
2048         },{
2049             .name = "localport",
2050             .type = QEMU_OPT_STRING,
2051         },{
2052             .name = "to",
2053             .type = QEMU_OPT_NUMBER,
2054         },{
2055             .name = "ipv4",
2056             .type = QEMU_OPT_BOOL,
2057         },{
2058             .name = "ipv6",
2059             .type = QEMU_OPT_BOOL,
2060         },{
2061             .name = "wait",
2062             .type = QEMU_OPT_BOOL,
2063         },{
2064             .name = "server",
2065             .type = QEMU_OPT_BOOL,
2066         },{
2067             .name = "delay",
2068             .type = QEMU_OPT_BOOL,
2069         },{
2070             .name = "reconnect",
2071             .type = QEMU_OPT_NUMBER,
2072         },{
2073             .name = "telnet",
2074             .type = QEMU_OPT_BOOL,
2075         },{
2076             .name = "tls-creds",
2077             .type = QEMU_OPT_STRING,
2078         },{
2079             .name = "width",
2080             .type = QEMU_OPT_NUMBER,
2081         },{
2082             .name = "height",
2083             .type = QEMU_OPT_NUMBER,
2084         },{
2085             .name = "cols",
2086             .type = QEMU_OPT_NUMBER,
2087         },{
2088             .name = "rows",
2089             .type = QEMU_OPT_NUMBER,
2090         },{
2091             .name = "mux",
2092             .type = QEMU_OPT_BOOL,
2093         },{
2094             .name = "signal",
2095             .type = QEMU_OPT_BOOL,
2096         },{
2097             .name = "name",
2098             .type = QEMU_OPT_STRING,
2099         },{
2100             .name = "debug",
2101             .type = QEMU_OPT_NUMBER,
2102         },{
2103             .name = "size",
2104             .type = QEMU_OPT_SIZE,
2105         },{
2106             .name = "chardev",
2107             .type = QEMU_OPT_STRING,
2108         },{
2109             .name = "append",
2110             .type = QEMU_OPT_BOOL,
2111         },{
2112             .name = "logfile",
2113             .type = QEMU_OPT_STRING,
2114         },{
2115             .name = "logappend",
2116             .type = QEMU_OPT_BOOL,
2117         },
2118         { /* end of list */ }
2119     },
2120 };
2121
2122 #ifdef _WIN32
2123
2124 static void qmp_chardev_open_serial(Chardev *chr,
2125                                     ChardevBackend *backend,
2126                                     bool *be_opened,
2127                                     Error **errp)
2128 {
2129     ChardevHostdev *serial = backend->u.serial.data;
2130
2131     win_chr_init(chr, serial->device, errp);
2132 }
2133
2134 #else /* WIN32 */
2135
2136 #ifdef HAVE_CHARDEV_SERIAL
2137 static void qmp_chardev_open_serial(Chardev *chr,
2138                                     ChardevBackend *backend,
2139                                     bool *be_opened,
2140                                     Error **errp)
2141 {
2142     ChardevHostdev *serial = backend->u.serial.data;
2143     int fd;
2144
2145     fd = qmp_chardev_open_file_source(serial->device, O_RDWR, errp);
2146     if (fd < 0) {
2147         return;
2148     }
2149     qemu_set_nonblock(fd);
2150     tty_serial_init(fd, 115200, 'N', 8, 1);
2151
2152     qemu_chr_open_fd(chr, fd, fd);
2153 }
2154 #endif
2155
2156 #ifdef HAVE_CHARDEV_PARPORT
2157 static void qmp_chardev_open_parallel(Chardev *chr,
2158                                       ChardevBackend *backend,
2159                                       bool *be_opened,
2160                                       Error **errp)
2161 {
2162     ChardevHostdev *parallel = backend->u.parallel.data;
2163     int fd;
2164
2165     fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
2166     if (fd < 0) {
2167         return;
2168     }
2169     qemu_chr_open_pp_fd(chr, fd, be_opened, errp);
2170 }
2171
2172 static void char_parallel_class_init(ObjectClass *oc, void *data)
2173 {
2174     ChardevClass *cc = CHARDEV_CLASS(oc);
2175
2176     cc->parse = qemu_chr_parse_parallel;
2177     cc->open = qmp_chardev_open_parallel;
2178 #if defined(__linux__)
2179     cc->chr_ioctl = pp_ioctl;
2180 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
2181     cc->chr_ioctl = pp_ioctl;
2182 #endif
2183 }
2184
2185 static void char_parallel_finalize(Object *obj)
2186 {
2187 #if defined(__linux__)
2188     Chardev *chr = CHARDEV(obj);
2189     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
2190     int fd = drv->fd;
2191
2192     pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2193     ioctl(fd, PPRELEASE);
2194     close(fd);
2195     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2196 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
2197     /* FIXME: close fd? */
2198 #endif
2199 }
2200
2201 static const TypeInfo char_parallel_type_info = {
2202     .name = TYPE_CHARDEV_PARALLEL,
2203     .parent = TYPE_CHARDEV,
2204     .instance_size = sizeof(ParallelChardev),
2205     .instance_finalize = char_parallel_finalize,
2206     .class_init = char_parallel_class_init,
2207 };
2208 #endif
2209
2210 #endif /* WIN32 */
2211
2212 #ifdef HAVE_CHARDEV_SERIAL
2213
2214 static void char_serial_class_init(ObjectClass *oc, void *data)
2215 {
2216     ChardevClass *cc = CHARDEV_CLASS(oc);
2217
2218     cc->parse = qemu_chr_parse_serial;
2219     cc->open = qmp_chardev_open_serial;
2220 #ifndef _WIN32
2221     cc->chr_ioctl = tty_serial_ioctl;
2222 #endif
2223 }
2224
2225 static const TypeInfo char_serial_type_info = {
2226     .name = TYPE_CHARDEV_SERIAL,
2227 #ifdef _WIN32
2228     .parent = TYPE_CHARDEV_WIN,
2229 #else
2230     .parent = TYPE_CHARDEV_FD,
2231 #endif
2232     .class_init = char_serial_class_init,
2233 };
2234 #endif
2235
2236 bool qemu_chr_has_feature(Chardev *chr,
2237                           ChardevFeature feature)
2238 {
2239     return test_bit(feature, chr->features);
2240 }
2241
2242 void qemu_chr_set_feature(Chardev *chr,
2243                            ChardevFeature feature)
2244 {
2245     return set_bit(feature, chr->features);
2246 }
2247
2248 Chardev *qemu_chardev_new(const char *id, const char *typename,
2249                           ChardevBackend *backend, Error **errp)
2250 {
2251     Chardev *chr = NULL;
2252     Error *local_err = NULL;
2253     bool be_opened = true;
2254
2255     assert(g_str_has_prefix(typename, "chardev-"));
2256
2257     chr = CHARDEV(object_new(typename));
2258     chr->label = g_strdup(id);
2259
2260     qemu_char_open(chr, backend, &be_opened, &local_err);
2261     if (local_err) {
2262         error_propagate(errp, local_err);
2263         object_unref(OBJECT(chr));
2264         return NULL;
2265     }
2266
2267     if (!chr->filename) {
2268         chr->filename = g_strdup(typename + 8);
2269     }
2270     if (be_opened) {
2271         qemu_chr_be_event(chr, CHR_EVENT_OPENED);
2272     }
2273
2274     return chr;
2275 }
2276
2277 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
2278                                Error **errp)
2279 {
2280     const ChardevClass *cc;
2281     ChardevReturn *ret;
2282     Chardev *chr;
2283
2284     cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp);
2285     if (!cc) {
2286         return NULL;
2287     }
2288
2289     chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)),
2290                            backend, errp);
2291     if (!chr) {
2292         return NULL;
2293     }
2294
2295     ret = g_new0(ChardevReturn, 1);
2296     if (CHARDEV_IS_PTY(chr)) {
2297         ret->pty = g_strdup(chr->filename + 4);
2298         ret->has_pty = true;
2299     }
2300
2301     return ret;
2302 }
2303
2304 void qmp_chardev_remove(const char *id, Error **errp)
2305 {
2306     Chardev *chr;
2307
2308     chr = qemu_chr_find(id);
2309     if (chr == NULL) {
2310         error_setg(errp, "Chardev '%s' not found", id);
2311         return;
2312     }
2313     if (qemu_chr_is_busy(chr)) {
2314         error_setg(errp, "Chardev '%s' is busy", id);
2315         return;
2316     }
2317     if (qemu_chr_replay(chr)) {
2318         error_setg(errp,
2319             "Chardev '%s' cannot be unplugged in record/replay mode", id);
2320         return;
2321     }
2322     qemu_chr_delete(chr);
2323 }
2324
2325 void qemu_chr_cleanup(void)
2326 {
2327     Chardev *chr, *tmp;
2328
2329     QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) {
2330         qemu_chr_delete(chr);
2331     }
2332 }
2333
2334 static void register_types(void)
2335 {
2336     type_register_static(&char_type_info);
2337 #ifdef HAVE_CHARDEV_SERIAL
2338     type_register_static(&char_serial_type_info);
2339 #endif
2340 #ifdef HAVE_CHARDEV_PARPORT
2341     type_register_static(&char_parallel_type_info);
2342 #endif
2343 #ifdef HAVE_CHARDEV_PTY
2344     type_register_static(&char_pty_type_info);
2345 #endif
2346 #ifdef _WIN32
2347     type_register_static(&char_console_type_info);
2348 #endif
2349     type_register_static(&char_pipe_type_info);
2350
2351     /* this must be done after machine init, since we register FEs with muxes
2352      * as part of realize functions like serial_isa_realizefn when -nographic
2353      * is specified
2354      */
2355     qemu_add_machine_init_done_notifier(&muxes_realize_notify);
2356 }
2357
2358 type_init(register_types);