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