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