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