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