4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 #include "qemu-common.h"
29 #include "qemu-timer.h"
30 #include "qemu-char.h"
33 #include "hw/msmouse.h"
34 #include "qemu-objects.h"
45 #include <sys/times.h>
49 #include <sys/ioctl.h>
50 #include <sys/resource.h>
51 #include <sys/socket.h>
52 #include <netinet/in.h>
54 #include <arpa/inet.h>
57 #include <sys/select.h>
60 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
62 #include <dev/ppbus/ppi.h>
63 #include <dev/ppbus/ppbconf.h>
64 #if defined(__GLIBC__)
67 #elif defined(__DragonFly__)
69 #include <dev/misc/ppi/ppi.h>
70 #include <bus/ppbus/ppbconf.h>
78 #include <linux/ppdev.h>
79 #include <linux/parport.h>
83 #include <sys/ethernet.h>
84 #include <sys/sockio.h>
85 #include <netinet/arp.h>
86 #include <netinet/in.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/ip.h>
89 #include <netinet/ip_icmp.h> // must come after ip.h
90 #include <netinet/udp.h>
91 #include <netinet/tcp.h>
99 #include "qemu_socket.h"
100 #include "ui/qemu-spice.h"
102 #define READ_BUF_LEN 4096
104 /***********************************************************/
105 /* character device */
107 static QTAILQ_HEAD(CharDriverStateHead
, CharDriverState
) chardevs
=
108 QTAILQ_HEAD_INITIALIZER(chardevs
);
110 static void qemu_chr_event(CharDriverState
*s
, int event
)
112 /* Keep track if the char device is open */
114 case CHR_EVENT_OPENED
:
117 case CHR_EVENT_CLOSED
:
124 s
->chr_event(s
->handler_opaque
, event
);
127 static void qemu_chr_generic_open_bh(void *opaque
)
129 CharDriverState
*s
= opaque
;
130 qemu_chr_event(s
, CHR_EVENT_OPENED
);
131 qemu_bh_delete(s
->bh
);
135 void qemu_chr_generic_open(CharDriverState
*s
)
138 s
->bh
= qemu_bh_new(qemu_chr_generic_open_bh
, s
);
139 qemu_bh_schedule(s
->bh
);
143 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
145 return s
->chr_write(s
, buf
, len
);
148 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
152 return s
->chr_ioctl(s
, cmd
, arg
);
155 int qemu_chr_can_read(CharDriverState
*s
)
157 if (!s
->chr_can_read
)
159 return s
->chr_can_read(s
->handler_opaque
);
162 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
164 s
->chr_read(s
->handler_opaque
, buf
, len
);
167 int qemu_chr_get_msgfd(CharDriverState
*s
)
169 return s
->get_msgfd
? s
->get_msgfd(s
) : -1;
172 void qemu_chr_accept_input(CharDriverState
*s
)
174 if (s
->chr_accept_input
)
175 s
->chr_accept_input(s
);
178 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
180 char buf
[READ_BUF_LEN
];
183 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
184 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
188 void qemu_chr_send_event(CharDriverState
*s
, int event
)
190 if (s
->chr_send_event
)
191 s
->chr_send_event(s
, event
);
194 void qemu_chr_add_handlers(CharDriverState
*s
,
195 IOCanReadHandler
*fd_can_read
,
196 IOReadHandler
*fd_read
,
197 IOEventHandler
*fd_event
,
200 s
->chr_can_read
= fd_can_read
;
201 s
->chr_read
= fd_read
;
202 s
->chr_event
= fd_event
;
203 s
->handler_opaque
= opaque
;
204 if (s
->chr_update_read_handler
)
205 s
->chr_update_read_handler(s
);
207 /* We're connecting to an already opened device, so let's make sure we
208 also get the open event */
210 qemu_chr_generic_open(s
);
214 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
219 static CharDriverState
*qemu_chr_open_null(QemuOpts
*opts
)
221 CharDriverState
*chr
;
223 chr
= qemu_mallocz(sizeof(CharDriverState
));
224 chr
->chr_write
= null_chr_write
;
228 /* MUX driver for serial I/O splitting */
230 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
231 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
233 IOCanReadHandler
*chr_can_read
[MAX_MUX
];
234 IOReadHandler
*chr_read
[MAX_MUX
];
235 IOEventHandler
*chr_event
[MAX_MUX
];
236 void *ext_opaque
[MAX_MUX
];
237 CharDriverState
*drv
;
242 /* Intermediate input buffer allows to catch escape sequences even if the
243 currently active device is not accepting any input - but only until it
245 unsigned char buffer
[MAX_MUX
][MUX_BUFFER_SIZE
];
250 int64_t timestamps_start
;
254 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
256 MuxDriver
*d
= chr
->opaque
;
258 if (!d
->timestamps
) {
259 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
264 for (i
= 0; i
< len
; i
++) {
270 ti
= qemu_get_clock(rt_clock
);
271 if (d
->timestamps_start
== -1)
272 d
->timestamps_start
= ti
;
273 ti
-= d
->timestamps_start
;
275 snprintf(buf1
, sizeof(buf1
),
276 "[%02d:%02d:%02d.%03d] ",
281 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
284 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
285 if (buf
[i
] == '\n') {
293 static const char * const mux_help
[] = {
294 "% h print this help\n\r",
295 "% x exit emulator\n\r",
296 "% s save disk data back to file (if -snapshot)\n\r",
297 "% t toggle console timestamps\n\r"
298 "% b send break (magic sysrq)\n\r",
299 "% c switch between console and monitor\n\r",
304 int term_escape_char
= 0x01; /* ctrl-a is used for escape */
305 static void mux_print_help(CharDriverState
*chr
)
308 char ebuf
[15] = "Escape-Char";
309 char cbuf
[50] = "\n\r";
311 if (term_escape_char
> 0 && term_escape_char
< 26) {
312 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
313 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
315 snprintf(cbuf
, sizeof(cbuf
),
316 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
319 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
320 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
321 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
322 if (mux_help
[i
][j
] == '%')
323 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
325 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
330 static void mux_chr_send_event(MuxDriver
*d
, int mux_nr
, int event
)
332 if (d
->chr_event
[mux_nr
])
333 d
->chr_event
[mux_nr
](d
->ext_opaque
[mux_nr
], event
);
336 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
338 if (d
->term_got_escape
) {
339 d
->term_got_escape
= 0;
340 if (ch
== term_escape_char
)
349 const char *term
= "QEMU: Terminated\n\r";
350 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
358 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
361 /* Switch to the next registered device */
362 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_OUT
);
364 if (d
->focus
>= d
->mux_cnt
)
366 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_IN
);
369 d
->timestamps
= !d
->timestamps
;
370 d
->timestamps_start
= -1;
374 } else if (ch
== term_escape_char
) {
375 d
->term_got_escape
= 1;
383 static void mux_chr_accept_input(CharDriverState
*chr
)
385 MuxDriver
*d
= chr
->opaque
;
388 while (d
->prod
[m
] != d
->cons
[m
] &&
389 d
->chr_can_read
[m
] &&
390 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
391 d
->chr_read
[m
](d
->ext_opaque
[m
],
392 &d
->buffer
[m
][d
->cons
[m
]++ & MUX_BUFFER_MASK
], 1);
396 static int mux_chr_can_read(void *opaque
)
398 CharDriverState
*chr
= opaque
;
399 MuxDriver
*d
= chr
->opaque
;
402 if ((d
->prod
[m
] - d
->cons
[m
]) < MUX_BUFFER_SIZE
)
404 if (d
->chr_can_read
[m
])
405 return d
->chr_can_read
[m
](d
->ext_opaque
[m
]);
409 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
411 CharDriverState
*chr
= opaque
;
412 MuxDriver
*d
= chr
->opaque
;
416 mux_chr_accept_input (opaque
);
418 for(i
= 0; i
< size
; i
++)
419 if (mux_proc_byte(chr
, d
, buf
[i
])) {
420 if (d
->prod
[m
] == d
->cons
[m
] &&
421 d
->chr_can_read
[m
] &&
422 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
423 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
425 d
->buffer
[m
][d
->prod
[m
]++ & MUX_BUFFER_MASK
] = buf
[i
];
429 static void mux_chr_event(void *opaque
, int event
)
431 CharDriverState
*chr
= opaque
;
432 MuxDriver
*d
= chr
->opaque
;
435 /* Send the event to all registered listeners */
436 for (i
= 0; i
< d
->mux_cnt
; i
++)
437 mux_chr_send_event(d
, i
, event
);
440 static void mux_chr_update_read_handler(CharDriverState
*chr
)
442 MuxDriver
*d
= chr
->opaque
;
444 if (d
->mux_cnt
>= MAX_MUX
) {
445 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
448 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
449 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
450 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
451 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
452 /* Fix up the real driver with mux routines */
453 if (d
->mux_cnt
== 0) {
454 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
457 if (d
->focus
!= -1) {
458 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_OUT
);
460 d
->focus
= d
->mux_cnt
;
462 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_IN
);
465 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
467 CharDriverState
*chr
;
470 chr
= qemu_mallocz(sizeof(CharDriverState
));
471 d
= qemu_mallocz(sizeof(MuxDriver
));
476 chr
->chr_write
= mux_chr_write
;
477 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
478 chr
->chr_accept_input
= mux_chr_accept_input
;
480 /* Muxes are always open on creation */
481 qemu_chr_generic_open(chr
);
488 int send_all(int fd
, const void *buf
, int len1
)
494 ret
= send(fd
, buf
, len
, 0);
496 errno
= WSAGetLastError();
497 if (errno
!= WSAEWOULDBLOCK
) {
500 } else if (ret
== 0) {
512 int send_all(int fd
, const void *_buf
, int len1
)
515 const uint8_t *buf
= _buf
;
519 ret
= write(fd
, buf
, len
);
521 if (errno
!= EINTR
&& errno
!= EAGAIN
)
523 } else if (ret
== 0) {
541 #define STDIO_MAX_CLIENTS 1
542 static int stdio_nb_clients
= 0;
544 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
546 FDCharDriver
*s
= chr
->opaque
;
547 return send_all(s
->fd_out
, buf
, len
);
550 static int fd_chr_read_poll(void *opaque
)
552 CharDriverState
*chr
= opaque
;
553 FDCharDriver
*s
= chr
->opaque
;
555 s
->max_size
= qemu_chr_can_read(chr
);
559 static void fd_chr_read(void *opaque
)
561 CharDriverState
*chr
= opaque
;
562 FDCharDriver
*s
= chr
->opaque
;
564 uint8_t buf
[READ_BUF_LEN
];
567 if (len
> s
->max_size
)
571 size
= read(s
->fd_in
, buf
, len
);
573 /* FD has been closed. Remove it from the active list. */
574 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
575 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
579 qemu_chr_read(chr
, buf
, size
);
583 static void fd_chr_update_read_handler(CharDriverState
*chr
)
585 FDCharDriver
*s
= chr
->opaque
;
588 if (display_type
== DT_NOGRAPHIC
&& s
->fd_in
== 0) {
590 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
591 fd_chr_read
, NULL
, chr
);
596 static void fd_chr_close(struct CharDriverState
*chr
)
598 FDCharDriver
*s
= chr
->opaque
;
601 if (display_type
== DT_NOGRAPHIC
&& s
->fd_in
== 0) {
603 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
608 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
611 /* open a character device to a unix fd */
612 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
614 CharDriverState
*chr
;
617 chr
= qemu_mallocz(sizeof(CharDriverState
));
618 s
= qemu_mallocz(sizeof(FDCharDriver
));
622 chr
->chr_write
= fd_chr_write
;
623 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
624 chr
->chr_close
= fd_chr_close
;
626 qemu_chr_generic_open(chr
);
631 static CharDriverState
*qemu_chr_open_file_out(QemuOpts
*opts
)
635 TFR(fd_out
= qemu_open(qemu_opt_get(opts
, "path"),
636 O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
639 return qemu_chr_open_fd(-1, fd_out
);
642 static CharDriverState
*qemu_chr_open_pipe(QemuOpts
*opts
)
645 char filename_in
[256], filename_out
[256];
646 const char *filename
= qemu_opt_get(opts
, "path");
648 if (filename
== NULL
) {
649 fprintf(stderr
, "chardev: pipe: no filename given\n");
653 snprintf(filename_in
, 256, "%s.in", filename
);
654 snprintf(filename_out
, 256, "%s.out", filename
);
655 TFR(fd_in
= qemu_open(filename_in
, O_RDWR
| O_BINARY
));
656 TFR(fd_out
= qemu_open(filename_out
, O_RDWR
| O_BINARY
));
657 if (fd_in
< 0 || fd_out
< 0) {
662 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
666 return qemu_chr_open_fd(fd_in
, fd_out
);
670 /* for STDIO, we handle the case where several clients use it
673 #define TERM_FIFO_MAX_SIZE 1
675 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
676 static int term_fifo_size
;
678 static int stdio_read_poll(void *opaque
)
680 CharDriverState
*chr
= opaque
;
682 /* try to flush the queue if needed */
683 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
684 qemu_chr_read(chr
, term_fifo
, 1);
687 /* see if we can absorb more chars */
688 if (term_fifo_size
== 0)
694 static void stdio_read(void *opaque
)
698 CharDriverState
*chr
= opaque
;
700 size
= read(0, buf
, 1);
702 /* stdin has been closed. Remove it from the active list. */
703 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
704 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
708 if (qemu_chr_can_read(chr
) > 0) {
709 qemu_chr_read(chr
, buf
, 1);
710 } else if (term_fifo_size
== 0) {
711 term_fifo
[term_fifo_size
++] = buf
[0];
716 /* init terminal so that we can grab keys */
717 static struct termios oldtty
;
718 static int old_fd0_flags
;
719 static int term_atexit_done
;
721 static void term_exit(void)
723 tcsetattr (0, TCSANOW
, &oldtty
);
724 fcntl(0, F_SETFL
, old_fd0_flags
);
727 static void term_init(QemuOpts
*opts
)
733 old_fd0_flags
= fcntl(0, F_GETFL
);
735 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
736 |INLCR
|IGNCR
|ICRNL
|IXON
);
737 tty
.c_oflag
|= OPOST
;
738 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
739 /* if graphical mode, we allow Ctrl-C handling */
740 if (!qemu_opt_get_bool(opts
, "signal", display_type
!= DT_NOGRAPHIC
))
741 tty
.c_lflag
&= ~ISIG
;
742 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
747 tcsetattr (0, TCSANOW
, &tty
);
749 if (!term_atexit_done
++)
752 fcntl(0, F_SETFL
, O_NONBLOCK
);
755 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
759 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
763 static CharDriverState
*qemu_chr_open_stdio(QemuOpts
*opts
)
765 CharDriverState
*chr
;
767 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
769 chr
= qemu_chr_open_fd(0, 1);
770 chr
->chr_close
= qemu_chr_close_stdio
;
771 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
779 /* Once Solaris has openpty(), this is going to be removed. */
780 static int openpty(int *amaster
, int *aslave
, char *name
,
781 struct termios
*termp
, struct winsize
*winp
)
784 int mfd
= -1, sfd
= -1;
786 *amaster
= *aslave
= -1;
788 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
792 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
795 if ((slave
= ptsname(mfd
)) == NULL
)
798 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
801 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
802 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
810 ioctl(sfd
, TIOCSWINSZ
, winp
);
821 static void cfmakeraw (struct termios
*termios_p
)
823 termios_p
->c_iflag
&=
824 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
825 termios_p
->c_oflag
&= ~OPOST
;
826 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
827 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
828 termios_p
->c_cflag
|= CS8
;
830 termios_p
->c_cc
[VMIN
] = 0;
831 termios_p
->c_cc
[VTIME
] = 0;
835 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
836 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
837 || defined(__GLIBC__)
847 static void pty_chr_update_read_handler(CharDriverState
*chr
);
848 static void pty_chr_state(CharDriverState
*chr
, int connected
);
850 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
852 PtyCharDriver
*s
= chr
->opaque
;
855 /* guest sends data, check for (re-)connect */
856 pty_chr_update_read_handler(chr
);
859 return send_all(s
->fd
, buf
, len
);
862 static int pty_chr_read_poll(void *opaque
)
864 CharDriverState
*chr
= opaque
;
865 PtyCharDriver
*s
= chr
->opaque
;
867 s
->read_bytes
= qemu_chr_can_read(chr
);
868 return s
->read_bytes
;
871 static void pty_chr_read(void *opaque
)
873 CharDriverState
*chr
= opaque
;
874 PtyCharDriver
*s
= chr
->opaque
;
876 uint8_t buf
[READ_BUF_LEN
];
879 if (len
> s
->read_bytes
)
883 size
= read(s
->fd
, buf
, len
);
884 if ((size
== -1 && errno
== EIO
) ||
886 pty_chr_state(chr
, 0);
890 pty_chr_state(chr
, 1);
891 qemu_chr_read(chr
, buf
, size
);
895 static void pty_chr_update_read_handler(CharDriverState
*chr
)
897 PtyCharDriver
*s
= chr
->opaque
;
899 qemu_set_fd_handler2(s
->fd
, pty_chr_read_poll
,
900 pty_chr_read
, NULL
, chr
);
903 * Short timeout here: just need wait long enougth that qemu makes
904 * it through the poll loop once. When reconnected we want a
905 * short timeout so we notice it almost instantly. Otherwise
906 * read() gives us -EIO instantly, making pty_chr_state() reset the
907 * timeout to the normal (much longer) poll interval before the
910 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 10);
913 static void pty_chr_state(CharDriverState
*chr
, int connected
)
915 PtyCharDriver
*s
= chr
->opaque
;
918 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
921 /* (re-)connect poll interval for idle guests: once per second.
922 * We check more frequently in case the guests sends data to
923 * the virtual device linked to our pty. */
924 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 1000);
927 qemu_chr_generic_open(chr
);
932 static void pty_chr_timer(void *opaque
)
934 struct CharDriverState
*chr
= opaque
;
935 PtyCharDriver
*s
= chr
->opaque
;
940 /* If we arrive here without polling being cleared due
941 * read returning -EIO, then we are (re-)connected */
942 pty_chr_state(chr
, 1);
947 pty_chr_update_read_handler(chr
);
950 static void pty_chr_close(struct CharDriverState
*chr
)
952 PtyCharDriver
*s
= chr
->opaque
;
954 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
956 qemu_del_timer(s
->timer
);
957 qemu_free_timer(s
->timer
);
959 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
962 static CharDriverState
*qemu_chr_open_pty(QemuOpts
*opts
)
964 CharDriverState
*chr
;
968 #if defined(__OpenBSD__) || defined(__DragonFly__)
969 char pty_name
[PATH_MAX
];
970 #define q_ptsname(x) pty_name
972 char *pty_name
= NULL
;
973 #define q_ptsname(x) ptsname(x)
976 chr
= qemu_mallocz(sizeof(CharDriverState
));
977 s
= qemu_mallocz(sizeof(PtyCharDriver
));
979 if (openpty(&s
->fd
, &slave_fd
, pty_name
, NULL
, NULL
) < 0) {
983 /* Set raw attributes on the pty. */
984 tcgetattr(slave_fd
, &tty
);
986 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
989 len
= strlen(q_ptsname(s
->fd
)) + 5;
990 chr
->filename
= qemu_malloc(len
);
991 snprintf(chr
->filename
, len
, "pty:%s", q_ptsname(s
->fd
));
992 qemu_opt_set(opts
, "path", q_ptsname(s
->fd
));
993 fprintf(stderr
, "char device redirected to %s\n", q_ptsname(s
->fd
));
996 chr
->chr_write
= pty_chr_write
;
997 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
998 chr
->chr_close
= pty_chr_close
;
1000 s
->timer
= qemu_new_timer(rt_clock
, pty_chr_timer
, chr
);
1005 static void tty_serial_init(int fd
, int speed
,
1006 int parity
, int data_bits
, int stop_bits
)
1012 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1013 speed
, parity
, data_bits
, stop_bits
);
1015 tcgetattr (fd
, &tty
);
1017 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
1018 speed
= speed
* 10 / 11;
1035 /* Non-Posix values follow. They may be unsupported on some systems. */
1037 check_speed(115200);
1039 check_speed(230400);
1042 check_speed(460800);
1045 check_speed(500000);
1048 check_speed(576000);
1051 check_speed(921600);
1054 check_speed(1000000);
1057 check_speed(1152000);
1060 check_speed(1500000);
1063 check_speed(2000000);
1066 check_speed(2500000);
1069 check_speed(3000000);
1072 check_speed(3500000);
1075 check_speed(4000000);
1080 cfsetispeed(&tty
, spd
);
1081 cfsetospeed(&tty
, spd
);
1083 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
1084 |INLCR
|IGNCR
|ICRNL
|IXON
);
1085 tty
.c_oflag
|= OPOST
;
1086 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
1087 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
1108 tty
.c_cflag
|= PARENB
;
1111 tty
.c_cflag
|= PARENB
| PARODD
;
1115 tty
.c_cflag
|= CSTOPB
;
1117 tcsetattr (fd
, TCSANOW
, &tty
);
1120 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1122 FDCharDriver
*s
= chr
->opaque
;
1125 case CHR_IOCTL_SERIAL_SET_PARAMS
:
1127 QEMUSerialSetParams
*ssp
= arg
;
1128 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
1129 ssp
->data_bits
, ssp
->stop_bits
);
1132 case CHR_IOCTL_SERIAL_SET_BREAK
:
1134 int enable
= *(int *)arg
;
1136 tcsendbreak(s
->fd_in
, 1);
1139 case CHR_IOCTL_SERIAL_GET_TIOCM
:
1142 int *targ
= (int *)arg
;
1143 ioctl(s
->fd_in
, TIOCMGET
, &sarg
);
1145 if (sarg
& TIOCM_CTS
)
1146 *targ
|= CHR_TIOCM_CTS
;
1147 if (sarg
& TIOCM_CAR
)
1148 *targ
|= CHR_TIOCM_CAR
;
1149 if (sarg
& TIOCM_DSR
)
1150 *targ
|= CHR_TIOCM_DSR
;
1151 if (sarg
& TIOCM_RI
)
1152 *targ
|= CHR_TIOCM_RI
;
1153 if (sarg
& TIOCM_DTR
)
1154 *targ
|= CHR_TIOCM_DTR
;
1155 if (sarg
& TIOCM_RTS
)
1156 *targ
|= CHR_TIOCM_RTS
;
1159 case CHR_IOCTL_SERIAL_SET_TIOCM
:
1161 int sarg
= *(int *)arg
;
1163 ioctl(s
->fd_in
, TIOCMGET
, &targ
);
1164 targ
&= ~(CHR_TIOCM_CTS
| CHR_TIOCM_CAR
| CHR_TIOCM_DSR
1165 | CHR_TIOCM_RI
| CHR_TIOCM_DTR
| CHR_TIOCM_RTS
);
1166 if (sarg
& CHR_TIOCM_CTS
)
1168 if (sarg
& CHR_TIOCM_CAR
)
1170 if (sarg
& CHR_TIOCM_DSR
)
1172 if (sarg
& CHR_TIOCM_RI
)
1174 if (sarg
& CHR_TIOCM_DTR
)
1176 if (sarg
& CHR_TIOCM_RTS
)
1178 ioctl(s
->fd_in
, TIOCMSET
, &targ
);
1187 static void qemu_chr_close_tty(CharDriverState
*chr
)
1189 FDCharDriver
*s
= chr
->opaque
;
1203 static CharDriverState
*qemu_chr_open_tty(QemuOpts
*opts
)
1205 const char *filename
= qemu_opt_get(opts
, "path");
1206 CharDriverState
*chr
;
1209 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
1213 tty_serial_init(fd
, 115200, 'N', 8, 1);
1214 chr
= qemu_chr_open_fd(fd
, fd
);
1219 chr
->chr_ioctl
= tty_serial_ioctl
;
1220 chr
->chr_close
= qemu_chr_close_tty
;
1223 #else /* ! __linux__ && ! __sun__ */
1224 static CharDriverState
*qemu_chr_open_pty(QemuOpts
*opts
)
1228 #endif /* __linux__ || __sun__ */
1230 #if defined(__linux__)
1234 } ParallelCharDriver
;
1236 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
1238 if (s
->mode
!= mode
) {
1240 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
1247 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1249 ParallelCharDriver
*drv
= chr
->opaque
;
1254 case CHR_IOCTL_PP_READ_DATA
:
1255 if (ioctl(fd
, PPRDATA
, &b
) < 0)
1257 *(uint8_t *)arg
= b
;
1259 case CHR_IOCTL_PP_WRITE_DATA
:
1260 b
= *(uint8_t *)arg
;
1261 if (ioctl(fd
, PPWDATA
, &b
) < 0)
1264 case CHR_IOCTL_PP_READ_CONTROL
:
1265 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
1267 /* Linux gives only the lowest bits, and no way to know data
1268 direction! For better compatibility set the fixed upper
1270 *(uint8_t *)arg
= b
| 0xc0;
1272 case CHR_IOCTL_PP_WRITE_CONTROL
:
1273 b
= *(uint8_t *)arg
;
1274 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
1277 case CHR_IOCTL_PP_READ_STATUS
:
1278 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
1280 *(uint8_t *)arg
= b
;
1282 case CHR_IOCTL_PP_DATA_DIR
:
1283 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
1286 case CHR_IOCTL_PP_EPP_READ_ADDR
:
1287 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
1288 struct ParallelIOArg
*parg
= arg
;
1289 int n
= read(fd
, parg
->buffer
, parg
->count
);
1290 if (n
!= parg
->count
) {
1295 case CHR_IOCTL_PP_EPP_READ
:
1296 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
1297 struct ParallelIOArg
*parg
= arg
;
1298 int n
= read(fd
, parg
->buffer
, parg
->count
);
1299 if (n
!= parg
->count
) {
1304 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
1305 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
1306 struct ParallelIOArg
*parg
= arg
;
1307 int n
= write(fd
, parg
->buffer
, parg
->count
);
1308 if (n
!= parg
->count
) {
1313 case CHR_IOCTL_PP_EPP_WRITE
:
1314 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
1315 struct ParallelIOArg
*parg
= arg
;
1316 int n
= write(fd
, parg
->buffer
, parg
->count
);
1317 if (n
!= parg
->count
) {
1328 static void pp_close(CharDriverState
*chr
)
1330 ParallelCharDriver
*drv
= chr
->opaque
;
1333 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
1334 ioctl(fd
, PPRELEASE
);
1337 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
1340 static CharDriverState
*qemu_chr_open_pp(QemuOpts
*opts
)
1342 const char *filename
= qemu_opt_get(opts
, "path");
1343 CharDriverState
*chr
;
1344 ParallelCharDriver
*drv
;
1347 TFR(fd
= open(filename
, O_RDWR
));
1351 if (ioctl(fd
, PPCLAIM
) < 0) {
1356 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
1358 drv
->mode
= IEEE1284_MODE_COMPAT
;
1360 chr
= qemu_mallocz(sizeof(CharDriverState
));
1361 chr
->chr_write
= null_chr_write
;
1362 chr
->chr_ioctl
= pp_ioctl
;
1363 chr
->chr_close
= pp_close
;
1366 qemu_chr_generic_open(chr
);
1370 #endif /* __linux__ */
1372 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1373 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1375 int fd
= (int)(long)chr
->opaque
;
1379 case CHR_IOCTL_PP_READ_DATA
:
1380 if (ioctl(fd
, PPIGDATA
, &b
) < 0)
1382 *(uint8_t *)arg
= b
;
1384 case CHR_IOCTL_PP_WRITE_DATA
:
1385 b
= *(uint8_t *)arg
;
1386 if (ioctl(fd
, PPISDATA
, &b
) < 0)
1389 case CHR_IOCTL_PP_READ_CONTROL
:
1390 if (ioctl(fd
, PPIGCTRL
, &b
) < 0)
1392 *(uint8_t *)arg
= b
;
1394 case CHR_IOCTL_PP_WRITE_CONTROL
:
1395 b
= *(uint8_t *)arg
;
1396 if (ioctl(fd
, PPISCTRL
, &b
) < 0)
1399 case CHR_IOCTL_PP_READ_STATUS
:
1400 if (ioctl(fd
, PPIGSTATUS
, &b
) < 0)
1402 *(uint8_t *)arg
= b
;
1410 static CharDriverState
*qemu_chr_open_pp(QemuOpts
*opts
)
1412 const char *filename
= qemu_opt_get(opts
, "path");
1413 CharDriverState
*chr
;
1416 fd
= open(filename
, O_RDWR
);
1420 chr
= qemu_mallocz(sizeof(CharDriverState
));
1421 chr
->opaque
= (void *)(long)fd
;
1422 chr
->chr_write
= null_chr_write
;
1423 chr
->chr_ioctl
= pp_ioctl
;
1432 HANDLE hcom
, hrecv
, hsend
;
1433 OVERLAPPED orecv
, osend
;
1438 #define NSENDBUF 2048
1439 #define NRECVBUF 2048
1440 #define MAXCONNECT 1
1441 #define NTIMEOUT 5000
1443 static int win_chr_poll(void *opaque
);
1444 static int win_chr_pipe_poll(void *opaque
);
1446 static void win_chr_close(CharDriverState
*chr
)
1448 WinCharState
*s
= chr
->opaque
;
1451 CloseHandle(s
->hsend
);
1455 CloseHandle(s
->hrecv
);
1459 CloseHandle(s
->hcom
);
1463 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
1465 qemu_del_polling_cb(win_chr_poll
, chr
);
1467 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
1470 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
1472 WinCharState
*s
= chr
->opaque
;
1474 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
1479 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1481 fprintf(stderr
, "Failed CreateEvent\n");
1484 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1486 fprintf(stderr
, "Failed CreateEvent\n");
1490 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
1491 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
1492 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
1493 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
1498 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
1499 fprintf(stderr
, "Failed SetupComm\n");
1503 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
1504 size
= sizeof(COMMCONFIG
);
1505 GetDefaultCommConfig(filename
, &comcfg
, &size
);
1506 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
1507 CommConfigDialog(filename
, NULL
, &comcfg
);
1509 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
1510 fprintf(stderr
, "Failed SetCommState\n");
1514 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
1515 fprintf(stderr
, "Failed SetCommMask\n");
1519 cto
.ReadIntervalTimeout
= MAXDWORD
;
1520 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
1521 fprintf(stderr
, "Failed SetCommTimeouts\n");
1525 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
1526 fprintf(stderr
, "Failed ClearCommError\n");
1529 qemu_add_polling_cb(win_chr_poll
, chr
);
1537 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
1539 WinCharState
*s
= chr
->opaque
;
1540 DWORD len
, ret
, size
, err
;
1543 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
1544 s
->osend
.hEvent
= s
->hsend
;
1547 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
1549 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
1551 err
= GetLastError();
1552 if (err
== ERROR_IO_PENDING
) {
1553 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
1571 static int win_chr_read_poll(CharDriverState
*chr
)
1573 WinCharState
*s
= chr
->opaque
;
1575 s
->max_size
= qemu_chr_can_read(chr
);
1579 static void win_chr_readfile(CharDriverState
*chr
)
1581 WinCharState
*s
= chr
->opaque
;
1583 uint8_t buf
[READ_BUF_LEN
];
1586 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
1587 s
->orecv
.hEvent
= s
->hrecv
;
1588 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
1590 err
= GetLastError();
1591 if (err
== ERROR_IO_PENDING
) {
1592 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
1597 qemu_chr_read(chr
, buf
, size
);
1601 static void win_chr_read(CharDriverState
*chr
)
1603 WinCharState
*s
= chr
->opaque
;
1605 if (s
->len
> s
->max_size
)
1606 s
->len
= s
->max_size
;
1610 win_chr_readfile(chr
);
1613 static int win_chr_poll(void *opaque
)
1615 CharDriverState
*chr
= opaque
;
1616 WinCharState
*s
= chr
->opaque
;
1620 ClearCommError(s
->hcom
, &comerr
, &status
);
1621 if (status
.cbInQue
> 0) {
1622 s
->len
= status
.cbInQue
;
1623 win_chr_read_poll(chr
);
1630 static CharDriverState
*qemu_chr_open_win(QemuOpts
*opts
)
1632 const char *filename
= qemu_opt_get(opts
, "path");
1633 CharDriverState
*chr
;
1636 chr
= qemu_mallocz(sizeof(CharDriverState
));
1637 s
= qemu_mallocz(sizeof(WinCharState
));
1639 chr
->chr_write
= win_chr_write
;
1640 chr
->chr_close
= win_chr_close
;
1642 if (win_chr_init(chr
, filename
) < 0) {
1647 qemu_chr_generic_open(chr
);
1651 static int win_chr_pipe_poll(void *opaque
)
1653 CharDriverState
*chr
= opaque
;
1654 WinCharState
*s
= chr
->opaque
;
1657 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
1660 win_chr_read_poll(chr
);
1667 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
1669 WinCharState
*s
= chr
->opaque
;
1677 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1679 fprintf(stderr
, "Failed CreateEvent\n");
1682 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1684 fprintf(stderr
, "Failed CreateEvent\n");
1688 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
1689 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
1690 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
1692 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
1693 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
1694 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
1699 ZeroMemory(&ov
, sizeof(ov
));
1700 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1701 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
1703 fprintf(stderr
, "Failed ConnectNamedPipe\n");
1707 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
1709 fprintf(stderr
, "Failed GetOverlappedResult\n");
1711 CloseHandle(ov
.hEvent
);
1718 CloseHandle(ov
.hEvent
);
1721 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
1730 static CharDriverState
*qemu_chr_open_win_pipe(QemuOpts
*opts
)
1732 const char *filename
= qemu_opt_get(opts
, "path");
1733 CharDriverState
*chr
;
1736 chr
= qemu_mallocz(sizeof(CharDriverState
));
1737 s
= qemu_mallocz(sizeof(WinCharState
));
1739 chr
->chr_write
= win_chr_write
;
1740 chr
->chr_close
= win_chr_close
;
1742 if (win_chr_pipe_init(chr
, filename
) < 0) {
1747 qemu_chr_generic_open(chr
);
1751 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
1753 CharDriverState
*chr
;
1756 chr
= qemu_mallocz(sizeof(CharDriverState
));
1757 s
= qemu_mallocz(sizeof(WinCharState
));
1760 chr
->chr_write
= win_chr_write
;
1761 qemu_chr_generic_open(chr
);
1765 static CharDriverState
*qemu_chr_open_win_con(QemuOpts
*opts
)
1767 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
1770 static CharDriverState
*qemu_chr_open_win_file_out(QemuOpts
*opts
)
1772 const char *file_out
= qemu_opt_get(opts
, "path");
1775 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
1776 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1777 if (fd_out
== INVALID_HANDLE_VALUE
)
1780 return qemu_chr_open_win_file(fd_out
);
1782 #endif /* !_WIN32 */
1784 /***********************************************************/
1785 /* UDP Net console */
1789 uint8_t buf
[READ_BUF_LEN
];
1795 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1797 NetCharDriver
*s
= chr
->opaque
;
1799 return send(s
->fd
, (const void *)buf
, len
, 0);
1802 static int udp_chr_read_poll(void *opaque
)
1804 CharDriverState
*chr
= opaque
;
1805 NetCharDriver
*s
= chr
->opaque
;
1807 s
->max_size
= qemu_chr_can_read(chr
);
1809 /* If there were any stray characters in the queue process them
1812 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
1813 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
1815 s
->max_size
= qemu_chr_can_read(chr
);
1820 static void udp_chr_read(void *opaque
)
1822 CharDriverState
*chr
= opaque
;
1823 NetCharDriver
*s
= chr
->opaque
;
1825 if (s
->max_size
== 0)
1827 s
->bufcnt
= recv(s
->fd
, (void *)s
->buf
, sizeof(s
->buf
), 0);
1828 s
->bufptr
= s
->bufcnt
;
1833 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
1834 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
1836 s
->max_size
= qemu_chr_can_read(chr
);
1840 static void udp_chr_update_read_handler(CharDriverState
*chr
)
1842 NetCharDriver
*s
= chr
->opaque
;
1845 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
1846 udp_chr_read
, NULL
, chr
);
1850 static void udp_chr_close(CharDriverState
*chr
)
1852 NetCharDriver
*s
= chr
->opaque
;
1854 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
1858 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
1861 static CharDriverState
*qemu_chr_open_udp(QemuOpts
*opts
)
1863 CharDriverState
*chr
= NULL
;
1864 NetCharDriver
*s
= NULL
;
1867 chr
= qemu_mallocz(sizeof(CharDriverState
));
1868 s
= qemu_mallocz(sizeof(NetCharDriver
));
1870 fd
= inet_dgram_opts(opts
);
1872 fprintf(stderr
, "inet_dgram_opts failed\n");
1880 chr
->chr_write
= udp_chr_write
;
1881 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
1882 chr
->chr_close
= udp_chr_close
;
1895 /***********************************************************/
1896 /* TCP Net console */
1908 static void tcp_chr_accept(void *opaque
);
1910 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1912 TCPCharDriver
*s
= chr
->opaque
;
1914 return send_all(s
->fd
, buf
, len
);
1916 /* XXX: indicate an error ? */
1921 static int tcp_chr_read_poll(void *opaque
)
1923 CharDriverState
*chr
= opaque
;
1924 TCPCharDriver
*s
= chr
->opaque
;
1927 s
->max_size
= qemu_chr_can_read(chr
);
1932 #define IAC_BREAK 243
1933 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
1935 uint8_t *buf
, int *size
)
1937 /* Handle any telnet client's basic IAC options to satisfy char by
1938 * char mode with no echo. All IAC options will be removed from
1939 * the buf and the do_telnetopt variable will be used to track the
1940 * state of the width of the IAC information.
1942 * IAC commands come in sets of 3 bytes with the exception of the
1943 * "IAC BREAK" command and the double IAC.
1949 for (i
= 0; i
< *size
; i
++) {
1950 if (s
->do_telnetopt
> 1) {
1951 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
1952 /* Double IAC means send an IAC */
1956 s
->do_telnetopt
= 1;
1958 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
1959 /* Handle IAC break commands by sending a serial break */
1960 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
1965 if (s
->do_telnetopt
>= 4) {
1966 s
->do_telnetopt
= 1;
1969 if ((unsigned char)buf
[i
] == IAC
) {
1970 s
->do_telnetopt
= 2;
1981 static int tcp_get_msgfd(CharDriverState
*chr
)
1983 TCPCharDriver
*s
= chr
->opaque
;
1990 static void unix_process_msgfd(CharDriverState
*chr
, struct msghdr
*msg
)
1992 TCPCharDriver
*s
= chr
->opaque
;
1993 struct cmsghdr
*cmsg
;
1995 for (cmsg
= CMSG_FIRSTHDR(msg
); cmsg
; cmsg
= CMSG_NXTHDR(msg
, cmsg
)) {
1998 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(int)) ||
1999 cmsg
->cmsg_level
!= SOL_SOCKET
||
2000 cmsg
->cmsg_type
!= SCM_RIGHTS
)
2003 fd
= *((int *)CMSG_DATA(cmsg
));
2013 static ssize_t
tcp_chr_recv(CharDriverState
*chr
, char *buf
, size_t len
)
2015 TCPCharDriver
*s
= chr
->opaque
;
2016 struct msghdr msg
= { NULL
, };
2017 struct iovec iov
[1];
2019 struct cmsghdr cmsg
;
2020 char control
[CMSG_SPACE(sizeof(int))];
2024 iov
[0].iov_base
= buf
;
2025 iov
[0].iov_len
= len
;
2029 msg
.msg_control
= &msg_control
;
2030 msg
.msg_controllen
= sizeof(msg_control
);
2032 ret
= recvmsg(s
->fd
, &msg
, 0);
2033 if (ret
> 0 && s
->is_unix
)
2034 unix_process_msgfd(chr
, &msg
);
2039 static ssize_t
tcp_chr_recv(CharDriverState
*chr
, char *buf
, size_t len
)
2041 TCPCharDriver
*s
= chr
->opaque
;
2042 return recv(s
->fd
, buf
, len
, 0);
2046 static void tcp_chr_read(void *opaque
)
2048 CharDriverState
*chr
= opaque
;
2049 TCPCharDriver
*s
= chr
->opaque
;
2050 uint8_t buf
[READ_BUF_LEN
];
2053 if (!s
->connected
|| s
->max_size
<= 0)
2056 if (len
> s
->max_size
)
2058 size
= tcp_chr_recv(chr
, (void *)buf
, len
);
2060 /* connection closed */
2062 if (s
->listen_fd
>= 0) {
2063 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
2065 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
2068 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
2069 } else if (size
> 0) {
2070 if (s
->do_telnetopt
)
2071 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
2073 qemu_chr_read(chr
, buf
, size
);
2078 CharDriverState
*qemu_chr_open_eventfd(int eventfd
)
2080 return qemu_chr_open_fd(eventfd
, eventfd
);
2084 static void tcp_chr_connect(void *opaque
)
2086 CharDriverState
*chr
= opaque
;
2087 TCPCharDriver
*s
= chr
->opaque
;
2090 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
2091 tcp_chr_read
, NULL
, chr
);
2092 qemu_chr_generic_open(chr
);
2095 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2096 static void tcp_chr_telnet_init(int fd
)
2099 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2100 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2101 send(fd
, (char *)buf
, 3, 0);
2102 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2103 send(fd
, (char *)buf
, 3, 0);
2104 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
2105 send(fd
, (char *)buf
, 3, 0);
2106 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
2107 send(fd
, (char *)buf
, 3, 0);
2110 static void socket_set_nodelay(int fd
)
2113 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
2116 static void tcp_chr_accept(void *opaque
)
2118 CharDriverState
*chr
= opaque
;
2119 TCPCharDriver
*s
= chr
->opaque
;
2120 struct sockaddr_in saddr
;
2122 struct sockaddr_un uaddr
;
2124 struct sockaddr
*addr
;
2131 len
= sizeof(uaddr
);
2132 addr
= (struct sockaddr
*)&uaddr
;
2136 len
= sizeof(saddr
);
2137 addr
= (struct sockaddr
*)&saddr
;
2139 fd
= qemu_accept(s
->listen_fd
, addr
, &len
);
2140 if (fd
< 0 && errno
!= EINTR
) {
2142 } else if (fd
>= 0) {
2143 if (s
->do_telnetopt
)
2144 tcp_chr_telnet_init(fd
);
2148 socket_set_nonblock(fd
);
2150 socket_set_nodelay(fd
);
2152 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
2153 tcp_chr_connect(chr
);
2156 static void tcp_chr_close(CharDriverState
*chr
)
2158 TCPCharDriver
*s
= chr
->opaque
;
2160 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
2163 if (s
->listen_fd
>= 0) {
2164 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
2165 closesocket(s
->listen_fd
);
2168 qemu_chr_event(chr
, CHR_EVENT_CLOSED
);
2171 static CharDriverState
*qemu_chr_open_socket(QemuOpts
*opts
)
2173 CharDriverState
*chr
= NULL
;
2174 TCPCharDriver
*s
= NULL
;
2182 is_listen
= qemu_opt_get_bool(opts
, "server", 0);
2183 is_waitconnect
= qemu_opt_get_bool(opts
, "wait", 1);
2184 is_telnet
= qemu_opt_get_bool(opts
, "telnet", 0);
2185 do_nodelay
= !qemu_opt_get_bool(opts
, "delay", 1);
2186 is_unix
= qemu_opt_get(opts
, "path") != NULL
;
2190 chr
= qemu_mallocz(sizeof(CharDriverState
));
2191 s
= qemu_mallocz(sizeof(TCPCharDriver
));
2195 fd
= unix_listen_opts(opts
);
2197 fd
= unix_connect_opts(opts
);
2201 fd
= inet_listen_opts(opts
, 0);
2203 fd
= inet_connect_opts(opts
);
2209 if (!is_waitconnect
)
2210 socket_set_nonblock(fd
);
2216 s
->is_unix
= is_unix
;
2217 s
->do_nodelay
= do_nodelay
&& !is_unix
;
2220 chr
->chr_write
= tcp_chr_write
;
2221 chr
->chr_close
= tcp_chr_close
;
2222 chr
->get_msgfd
= tcp_get_msgfd
;
2226 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
2228 s
->do_telnetopt
= 1;
2233 socket_set_nodelay(fd
);
2234 tcp_chr_connect(chr
);
2237 /* for "info chardev" monitor command */
2238 chr
->filename
= qemu_malloc(256);
2240 snprintf(chr
->filename
, 256, "unix:%s%s",
2241 qemu_opt_get(opts
, "path"),
2242 qemu_opt_get_bool(opts
, "server", 0) ? ",server" : "");
2243 } else if (is_telnet
) {
2244 snprintf(chr
->filename
, 256, "telnet:%s:%s%s",
2245 qemu_opt_get(opts
, "host"), qemu_opt_get(opts
, "port"),
2246 qemu_opt_get_bool(opts
, "server", 0) ? ",server" : "");
2248 snprintf(chr
->filename
, 256, "tcp:%s:%s%s",
2249 qemu_opt_get(opts
, "host"), qemu_opt_get(opts
, "port"),
2250 qemu_opt_get_bool(opts
, "server", 0) ? ",server" : "");
2253 if (is_listen
&& is_waitconnect
) {
2254 printf("QEMU waiting for connection on: %s\n",
2256 tcp_chr_accept(chr
);
2257 socket_set_nonblock(s
->listen_fd
);
2269 /***********************************************************/
2270 /* Memory chardev */
2273 size_t outbuf_capacity
;
2277 static int mem_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2279 MemoryDriver
*d
= chr
->opaque
;
2281 /* TODO: the QString implementation has the same code, we should
2282 * introduce a generic way to do this in cutils.c */
2283 if (d
->outbuf_capacity
< d
->outbuf_size
+ len
) {
2285 d
->outbuf_capacity
+= len
;
2286 d
->outbuf_capacity
*= 2;
2287 d
->outbuf
= qemu_realloc(d
->outbuf
, d
->outbuf_capacity
);
2290 memcpy(d
->outbuf
+ d
->outbuf_size
, buf
, len
);
2291 d
->outbuf_size
+= len
;
2296 void qemu_chr_init_mem(CharDriverState
*chr
)
2300 d
= qemu_malloc(sizeof(*d
));
2302 d
->outbuf_capacity
= 4096;
2303 d
->outbuf
= qemu_mallocz(d
->outbuf_capacity
);
2305 memset(chr
, 0, sizeof(*chr
));
2307 chr
->chr_write
= mem_chr_write
;
2310 QString
*qemu_chr_mem_to_qs(CharDriverState
*chr
)
2312 MemoryDriver
*d
= chr
->opaque
;
2313 return qstring_from_substr((char *) d
->outbuf
, 0, d
->outbuf_size
- 1);
2316 /* NOTE: this driver can not be closed with qemu_chr_close()! */
2317 void qemu_chr_close_mem(CharDriverState
*chr
)
2319 MemoryDriver
*d
= chr
->opaque
;
2321 qemu_free(d
->outbuf
);
2322 qemu_free(chr
->opaque
);
2324 chr
->chr_write
= NULL
;
2327 size_t qemu_chr_mem_osize(const CharDriverState
*chr
)
2329 const MemoryDriver
*d
= chr
->opaque
;
2330 return d
->outbuf_size
;
2333 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
)
2335 char host
[65], port
[33], width
[8], height
[8];
2340 opts
= qemu_opts_create(qemu_find_opts("chardev"), label
, 1);
2344 if (strstart(filename
, "mon:", &p
)) {
2346 qemu_opt_set(opts
, "mux", "on");
2349 if (strcmp(filename
, "null") == 0 ||
2350 strcmp(filename
, "pty") == 0 ||
2351 strcmp(filename
, "msmouse") == 0 ||
2352 strcmp(filename
, "braille") == 0 ||
2353 strcmp(filename
, "stdio") == 0) {
2354 qemu_opt_set(opts
, "backend", filename
);
2357 if (strstart(filename
, "vc", &p
)) {
2358 qemu_opt_set(opts
, "backend", "vc");
2360 if (sscanf(p
+1, "%8[0-9]x%8[0-9]", width
, height
) == 2) {
2362 qemu_opt_set(opts
, "width", width
);
2363 qemu_opt_set(opts
, "height", height
);
2364 } else if (sscanf(p
+1, "%8[0-9]Cx%8[0-9]C", width
, height
) == 2) {
2366 qemu_opt_set(opts
, "cols", width
);
2367 qemu_opt_set(opts
, "rows", height
);
2374 if (strcmp(filename
, "con:") == 0) {
2375 qemu_opt_set(opts
, "backend", "console");
2378 if (strstart(filename
, "COM", NULL
)) {
2379 qemu_opt_set(opts
, "backend", "serial");
2380 qemu_opt_set(opts
, "path", filename
);
2383 if (strstart(filename
, "file:", &p
)) {
2384 qemu_opt_set(opts
, "backend", "file");
2385 qemu_opt_set(opts
, "path", p
);
2388 if (strstart(filename
, "pipe:", &p
)) {
2389 qemu_opt_set(opts
, "backend", "pipe");
2390 qemu_opt_set(opts
, "path", p
);
2393 if (strstart(filename
, "tcp:", &p
) ||
2394 strstart(filename
, "telnet:", &p
)) {
2395 if (sscanf(p
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) < 2) {
2397 if (sscanf(p
, ":%32[^,]%n", port
, &pos
) < 1)
2400 qemu_opt_set(opts
, "backend", "socket");
2401 qemu_opt_set(opts
, "host", host
);
2402 qemu_opt_set(opts
, "port", port
);
2403 if (p
[pos
] == ',') {
2404 if (qemu_opts_do_parse(opts
, p
+pos
+1, NULL
) != 0)
2407 if (strstart(filename
, "telnet:", &p
))
2408 qemu_opt_set(opts
, "telnet", "on");
2411 if (strstart(filename
, "udp:", &p
)) {
2412 qemu_opt_set(opts
, "backend", "udp");
2413 if (sscanf(p
, "%64[^:]:%32[^@,]%n", host
, port
, &pos
) < 2) {
2415 if (sscanf(p
, ":%32[^@,]%n", port
, &pos
) < 1) {
2419 qemu_opt_set(opts
, "host", host
);
2420 qemu_opt_set(opts
, "port", port
);
2421 if (p
[pos
] == '@') {
2423 if (sscanf(p
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) < 2) {
2425 if (sscanf(p
, ":%32[^,]%n", port
, &pos
) < 1) {
2429 qemu_opt_set(opts
, "localaddr", host
);
2430 qemu_opt_set(opts
, "localport", port
);
2434 if (strstart(filename
, "unix:", &p
)) {
2435 qemu_opt_set(opts
, "backend", "socket");
2436 if (qemu_opts_do_parse(opts
, p
, "path") != 0)
2440 if (strstart(filename
, "/dev/parport", NULL
) ||
2441 strstart(filename
, "/dev/ppi", NULL
)) {
2442 qemu_opt_set(opts
, "backend", "parport");
2443 qemu_opt_set(opts
, "path", filename
);
2446 if (strstart(filename
, "/dev/", NULL
)) {
2447 qemu_opt_set(opts
, "backend", "tty");
2448 qemu_opt_set(opts
, "path", filename
);
2453 qemu_opts_del(opts
);
2457 static const struct {
2459 CharDriverState
*(*open
)(QemuOpts
*opts
);
2460 } backend_table
[] = {
2461 { .name
= "null", .open
= qemu_chr_open_null
},
2462 { .name
= "socket", .open
= qemu_chr_open_socket
},
2463 { .name
= "udp", .open
= qemu_chr_open_udp
},
2464 { .name
= "msmouse", .open
= qemu_chr_open_msmouse
},
2465 { .name
= "vc", .open
= text_console_init
},
2467 { .name
= "file", .open
= qemu_chr_open_win_file_out
},
2468 { .name
= "pipe", .open
= qemu_chr_open_win_pipe
},
2469 { .name
= "console", .open
= qemu_chr_open_win_con
},
2470 { .name
= "serial", .open
= qemu_chr_open_win
},
2472 { .name
= "file", .open
= qemu_chr_open_file_out
},
2473 { .name
= "pipe", .open
= qemu_chr_open_pipe
},
2474 { .name
= "pty", .open
= qemu_chr_open_pty
},
2475 { .name
= "stdio", .open
= qemu_chr_open_stdio
},
2477 #ifdef CONFIG_BRLAPI
2478 { .name
= "braille", .open
= chr_baum_init
},
2480 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2481 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
2482 || defined(__FreeBSD_kernel__)
2483 { .name
= "tty", .open
= qemu_chr_open_tty
},
2485 #if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__) \
2486 || defined(__FreeBSD_kernel__)
2487 { .name
= "parport", .open
= qemu_chr_open_pp
},
2490 { .name
= "spicevmc", .open
= qemu_chr_open_spice
},
2494 CharDriverState
*qemu_chr_open_opts(QemuOpts
*opts
,
2495 void (*init
)(struct CharDriverState
*s
))
2497 CharDriverState
*chr
;
2500 if (qemu_opts_id(opts
) == NULL
) {
2501 fprintf(stderr
, "chardev: no id specified\n");
2505 for (i
= 0; i
< ARRAY_SIZE(backend_table
); i
++) {
2506 if (strcmp(backend_table
[i
].name
, qemu_opt_get(opts
, "backend")) == 0)
2509 if (i
== ARRAY_SIZE(backend_table
)) {
2510 fprintf(stderr
, "chardev: backend \"%s\" not found\n",
2511 qemu_opt_get(opts
, "backend"));
2515 chr
= backend_table
[i
].open(opts
);
2517 fprintf(stderr
, "chardev: opening backend \"%s\" failed\n",
2518 qemu_opt_get(opts
, "backend"));
2523 chr
->filename
= qemu_strdup(qemu_opt_get(opts
, "backend"));
2525 QTAILQ_INSERT_TAIL(&chardevs
, chr
, next
);
2527 if (qemu_opt_get_bool(opts
, "mux", 0)) {
2528 CharDriverState
*base
= chr
;
2529 int len
= strlen(qemu_opts_id(opts
)) + 6;
2530 base
->label
= qemu_malloc(len
);
2531 snprintf(base
->label
, len
, "%s-base", qemu_opts_id(opts
));
2532 chr
= qemu_chr_open_mux(base
);
2533 chr
->filename
= base
->filename
;
2534 QTAILQ_INSERT_TAIL(&chardevs
, chr
, next
);
2536 chr
->label
= qemu_strdup(qemu_opts_id(opts
));
2540 CharDriverState
*qemu_chr_open(const char *label
, const char *filename
, void (*init
)(struct CharDriverState
*s
))
2543 CharDriverState
*chr
;
2546 if (strstart(filename
, "chardev:", &p
)) {
2547 return qemu_chr_find(p
);
2550 opts
= qemu_chr_parse_compat(label
, filename
);
2554 chr
= qemu_chr_open_opts(opts
, init
);
2555 if (chr
&& qemu_opt_get_bool(opts
, "mux", 0)) {
2556 monitor_init(chr
, MONITOR_USE_READLINE
);
2561 void qemu_chr_set_echo(struct CharDriverState
*chr
, bool echo
)
2563 if (chr
->chr_set_echo
) {
2564 chr
->chr_set_echo(chr
, echo
);
2568 void qemu_chr_close(CharDriverState
*chr
)
2570 QTAILQ_REMOVE(&chardevs
, chr
, next
);
2572 chr
->chr_close(chr
);
2573 qemu_free(chr
->filename
);
2574 qemu_free(chr
->label
);
2578 static void qemu_chr_qlist_iter(QObject
*obj
, void *opaque
)
2581 Monitor
*mon
= opaque
;
2583 chr_dict
= qobject_to_qdict(obj
);
2584 monitor_printf(mon
, "%s: filename=%s\n", qdict_get_str(chr_dict
, "label"),
2585 qdict_get_str(chr_dict
, "filename"));
2588 void qemu_chr_info_print(Monitor
*mon
, const QObject
*ret_data
)
2590 qlist_iter(qobject_to_qlist(ret_data
), qemu_chr_qlist_iter
, mon
);
2593 void qemu_chr_info(Monitor
*mon
, QObject
**ret_data
)
2596 CharDriverState
*chr
;
2598 chr_list
= qlist_new();
2600 QTAILQ_FOREACH(chr
, &chardevs
, next
) {
2601 QObject
*obj
= qobject_from_jsonf("{ 'label': %s, 'filename': %s }",
2602 chr
->label
, chr
->filename
);
2603 qlist_append_obj(chr_list
, obj
);
2606 *ret_data
= QOBJECT(chr_list
);
2609 CharDriverState
*qemu_chr_find(const char *name
)
2611 CharDriverState
*chr
;
2613 QTAILQ_FOREACH(chr
, &chardevs
, next
) {
2614 if (strcmp(chr
->label
, name
) != 0)