]> git.proxmox.com Git - qemu.git/blob - qemu-char.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'bonzini/scsi-next' into staging
[qemu.git] / qemu-char.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu-common.h"
25 #include "net.h"
26 #include "monitor.h"
27 #include "console.h"
28 #include "sysemu.h"
29 #include "qemu-timer.h"
30 #include "qemu-char.h"
31 #include "hw/usb.h"
32 #include "hw/baum.h"
33 #include "hw/msmouse.h"
34 #include "qmp-commands.h"
35
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <time.h>
39 #include <errno.h>
40 #include <sys/time.h>
41 #include <zlib.h>
42
43 #ifndef _WIN32
44 #include <sys/times.h>
45 #include <sys/wait.h>
46 #include <termios.h>
47 #include <sys/mman.h>
48 #include <sys/ioctl.h>
49 #include <sys/resource.h>
50 #include <sys/socket.h>
51 #include <netinet/in.h>
52 #include <net/if.h>
53 #include <arpa/inet.h>
54 #include <dirent.h>
55 #include <netdb.h>
56 #include <sys/select.h>
57 #ifdef CONFIG_BSD
58 #include <sys/stat.h>
59 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
60 #include <libutil.h>
61 #include <dev/ppbus/ppi.h>
62 #include <dev/ppbus/ppbconf.h>
63 #if defined(__GLIBC__)
64 #include <pty.h>
65 #endif
66 #elif defined(__DragonFly__)
67 #include <libutil.h>
68 #include <dev/misc/ppi/ppi.h>
69 #include <bus/ppbus/ppbconf.h>
70 #else
71 #include <util.h>
72 #endif
73 #else
74 #ifdef __linux__
75 #include <pty.h>
76
77 #include <linux/ppdev.h>
78 #include <linux/parport.h>
79 #endif
80 #ifdef __sun__
81 #include <sys/stat.h>
82 #include <sys/ethernet.h>
83 #include <sys/sockio.h>
84 #include <netinet/arp.h>
85 #include <netinet/in.h>
86 #include <netinet/in_systm.h>
87 #include <netinet/ip.h>
88 #include <netinet/ip_icmp.h> // must come after ip.h
89 #include <netinet/udp.h>
90 #include <netinet/tcp.h>
91 #include <net/if.h>
92 #include <syslog.h>
93 #include <stropts.h>
94 #endif
95 #endif
96 #endif
97
98 #include "qemu_socket.h"
99 #include "ui/qemu-spice.h"
100
101 #define READ_BUF_LEN 4096
102
103 /***********************************************************/
104 /* character device */
105
106 static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
107 QTAILQ_HEAD_INITIALIZER(chardevs);
108
109 void qemu_chr_be_event(CharDriverState *s, int event)
110 {
111 /* Keep track if the char device is open */
112 switch (event) {
113 case CHR_EVENT_OPENED:
114 s->opened = 1;
115 break;
116 case CHR_EVENT_CLOSED:
117 s->opened = 0;
118 break;
119 }
120
121 if (!s->chr_event)
122 return;
123 s->chr_event(s->handler_opaque, event);
124 }
125
126 static void qemu_chr_generic_open_bh(void *opaque)
127 {
128 CharDriverState *s = opaque;
129 qemu_chr_be_event(s, CHR_EVENT_OPENED);
130 qemu_bh_delete(s->bh);
131 s->bh = NULL;
132 }
133
134 void qemu_chr_generic_open(CharDriverState *s)
135 {
136 if (s->bh == NULL) {
137 s->bh = qemu_bh_new(qemu_chr_generic_open_bh, s);
138 qemu_bh_schedule(s->bh);
139 }
140 }
141
142 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
143 {
144 return s->chr_write(s, buf, len);
145 }
146
147 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
148 {
149 if (!s->chr_ioctl)
150 return -ENOTSUP;
151 return s->chr_ioctl(s, cmd, arg);
152 }
153
154 int qemu_chr_be_can_write(CharDriverState *s)
155 {
156 if (!s->chr_can_read)
157 return 0;
158 return s->chr_can_read(s->handler_opaque);
159 }
160
161 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
162 {
163 s->chr_read(s->handler_opaque, buf, len);
164 }
165
166 int qemu_chr_fe_get_msgfd(CharDriverState *s)
167 {
168 return s->get_msgfd ? s->get_msgfd(s) : -1;
169 }
170
171 int qemu_chr_add_client(CharDriverState *s, int fd)
172 {
173 return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
174 }
175
176 void qemu_chr_accept_input(CharDriverState *s)
177 {
178 if (s->chr_accept_input)
179 s->chr_accept_input(s);
180 qemu_notify_event();
181 }
182
183 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
184 {
185 char buf[READ_BUF_LEN];
186 va_list ap;
187 va_start(ap, fmt);
188 vsnprintf(buf, sizeof(buf), fmt, ap);
189 qemu_chr_fe_write(s, (uint8_t *)buf, strlen(buf));
190 va_end(ap);
191 }
192
193 void qemu_chr_add_handlers(CharDriverState *s,
194 IOCanReadHandler *fd_can_read,
195 IOReadHandler *fd_read,
196 IOEventHandler *fd_event,
197 void *opaque)
198 {
199 if (!opaque && !fd_can_read && !fd_read && !fd_event) {
200 /* chr driver being released. */
201 ++s->avail_connections;
202 }
203 s->chr_can_read = fd_can_read;
204 s->chr_read = fd_read;
205 s->chr_event = fd_event;
206 s->handler_opaque = opaque;
207 if (s->chr_update_read_handler)
208 s->chr_update_read_handler(s);
209
210 /* We're connecting to an already opened device, so let's make sure we
211 also get the open event */
212 if (s->opened) {
213 qemu_chr_generic_open(s);
214 }
215 }
216
217 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
218 {
219 return len;
220 }
221
222 static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
223 {
224 CharDriverState *chr;
225
226 chr = g_malloc0(sizeof(CharDriverState));
227 chr->chr_write = null_chr_write;
228 return chr;
229 }
230
231 /* MUX driver for serial I/O splitting */
232 #define MAX_MUX 4
233 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
234 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
235 typedef struct {
236 IOCanReadHandler *chr_can_read[MAX_MUX];
237 IOReadHandler *chr_read[MAX_MUX];
238 IOEventHandler *chr_event[MAX_MUX];
239 void *ext_opaque[MAX_MUX];
240 CharDriverState *drv;
241 int focus;
242 int mux_cnt;
243 int term_got_escape;
244 int max_size;
245 /* Intermediate input buffer allows to catch escape sequences even if the
246 currently active device is not accepting any input - but only until it
247 is full as well. */
248 unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
249 int prod[MAX_MUX];
250 int cons[MAX_MUX];
251 int timestamps;
252 int linestart;
253 int64_t timestamps_start;
254 } MuxDriver;
255
256
257 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
258 {
259 MuxDriver *d = chr->opaque;
260 int ret;
261 if (!d->timestamps) {
262 ret = d->drv->chr_write(d->drv, buf, len);
263 } else {
264 int i;
265
266 ret = 0;
267 for (i = 0; i < len; i++) {
268 if (d->linestart) {
269 char buf1[64];
270 int64_t ti;
271 int secs;
272
273 ti = qemu_get_clock_ms(rt_clock);
274 if (d->timestamps_start == -1)
275 d->timestamps_start = ti;
276 ti -= d->timestamps_start;
277 secs = ti / 1000;
278 snprintf(buf1, sizeof(buf1),
279 "[%02d:%02d:%02d.%03d] ",
280 secs / 3600,
281 (secs / 60) % 60,
282 secs % 60,
283 (int)(ti % 1000));
284 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
285 d->linestart = 0;
286 }
287 ret += d->drv->chr_write(d->drv, buf+i, 1);
288 if (buf[i] == '\n') {
289 d->linestart = 1;
290 }
291 }
292 }
293 return ret;
294 }
295
296 static const char * const mux_help[] = {
297 "% h print this help\n\r",
298 "% x exit emulator\n\r",
299 "% s save disk data back to file (if -snapshot)\n\r",
300 "% t toggle console timestamps\n\r"
301 "% b send break (magic sysrq)\n\r",
302 "% c switch between console and monitor\n\r",
303 "% % sends %\n\r",
304 NULL
305 };
306
307 int term_escape_char = 0x01; /* ctrl-a is used for escape */
308 static void mux_print_help(CharDriverState *chr)
309 {
310 int i, j;
311 char ebuf[15] = "Escape-Char";
312 char cbuf[50] = "\n\r";
313
314 if (term_escape_char > 0 && term_escape_char < 26) {
315 snprintf(cbuf, sizeof(cbuf), "\n\r");
316 snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
317 } else {
318 snprintf(cbuf, sizeof(cbuf),
319 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
320 term_escape_char);
321 }
322 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
323 for (i = 0; mux_help[i] != NULL; i++) {
324 for (j=0; mux_help[i][j] != '\0'; j++) {
325 if (mux_help[i][j] == '%')
326 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
327 else
328 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
329 }
330 }
331 }
332
333 static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
334 {
335 if (d->chr_event[mux_nr])
336 d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
337 }
338
339 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
340 {
341 if (d->term_got_escape) {
342 d->term_got_escape = 0;
343 if (ch == term_escape_char)
344 goto send_char;
345 switch(ch) {
346 case '?':
347 case 'h':
348 mux_print_help(chr);
349 break;
350 case 'x':
351 {
352 const char *term = "QEMU: Terminated\n\r";
353 chr->chr_write(chr,(uint8_t *)term,strlen(term));
354 exit(0);
355 break;
356 }
357 case 's':
358 bdrv_commit_all();
359 break;
360 case 'b':
361 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
362 break;
363 case 'c':
364 /* Switch to the next registered device */
365 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
366 d->focus++;
367 if (d->focus >= d->mux_cnt)
368 d->focus = 0;
369 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
370 break;
371 case 't':
372 d->timestamps = !d->timestamps;
373 d->timestamps_start = -1;
374 d->linestart = 0;
375 break;
376 }
377 } else if (ch == term_escape_char) {
378 d->term_got_escape = 1;
379 } else {
380 send_char:
381 return 1;
382 }
383 return 0;
384 }
385
386 static void mux_chr_accept_input(CharDriverState *chr)
387 {
388 MuxDriver *d = chr->opaque;
389 int m = d->focus;
390
391 while (d->prod[m] != d->cons[m] &&
392 d->chr_can_read[m] &&
393 d->chr_can_read[m](d->ext_opaque[m])) {
394 d->chr_read[m](d->ext_opaque[m],
395 &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
396 }
397 }
398
399 static int mux_chr_can_read(void *opaque)
400 {
401 CharDriverState *chr = opaque;
402 MuxDriver *d = chr->opaque;
403 int m = d->focus;
404
405 if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
406 return 1;
407 if (d->chr_can_read[m])
408 return d->chr_can_read[m](d->ext_opaque[m]);
409 return 0;
410 }
411
412 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
413 {
414 CharDriverState *chr = opaque;
415 MuxDriver *d = chr->opaque;
416 int m = d->focus;
417 int i;
418
419 mux_chr_accept_input (opaque);
420
421 for(i = 0; i < size; i++)
422 if (mux_proc_byte(chr, d, buf[i])) {
423 if (d->prod[m] == d->cons[m] &&
424 d->chr_can_read[m] &&
425 d->chr_can_read[m](d->ext_opaque[m]))
426 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
427 else
428 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
429 }
430 }
431
432 static void mux_chr_event(void *opaque, int event)
433 {
434 CharDriverState *chr = opaque;
435 MuxDriver *d = chr->opaque;
436 int i;
437
438 /* Send the event to all registered listeners */
439 for (i = 0; i < d->mux_cnt; i++)
440 mux_chr_send_event(d, i, event);
441 }
442
443 static void mux_chr_update_read_handler(CharDriverState *chr)
444 {
445 MuxDriver *d = chr->opaque;
446
447 if (d->mux_cnt >= MAX_MUX) {
448 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
449 return;
450 }
451 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
452 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
453 d->chr_read[d->mux_cnt] = chr->chr_read;
454 d->chr_event[d->mux_cnt] = chr->chr_event;
455 /* Fix up the real driver with mux routines */
456 if (d->mux_cnt == 0) {
457 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
458 mux_chr_event, chr);
459 }
460 if (d->focus != -1) {
461 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
462 }
463 d->focus = d->mux_cnt;
464 d->mux_cnt++;
465 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
466 }
467
468 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
469 {
470 CharDriverState *chr;
471 MuxDriver *d;
472
473 chr = g_malloc0(sizeof(CharDriverState));
474 d = g_malloc0(sizeof(MuxDriver));
475
476 chr->opaque = d;
477 d->drv = drv;
478 d->focus = -1;
479 chr->chr_write = mux_chr_write;
480 chr->chr_update_read_handler = mux_chr_update_read_handler;
481 chr->chr_accept_input = mux_chr_accept_input;
482 /* Frontend guest-open / -close notification is not support with muxes */
483 chr->chr_guest_open = NULL;
484 chr->chr_guest_close = NULL;
485
486 /* Muxes are always open on creation */
487 qemu_chr_generic_open(chr);
488
489 return chr;
490 }
491
492
493 #ifdef _WIN32
494 int send_all(int fd, const void *buf, int len1)
495 {
496 int ret, len;
497
498 len = len1;
499 while (len > 0) {
500 ret = send(fd, buf, len, 0);
501 if (ret < 0) {
502 errno = WSAGetLastError();
503 if (errno != WSAEWOULDBLOCK) {
504 return -1;
505 }
506 } else if (ret == 0) {
507 break;
508 } else {
509 buf += ret;
510 len -= ret;
511 }
512 }
513 return len1 - len;
514 }
515
516 #else
517
518 int send_all(int fd, const void *_buf, int len1)
519 {
520 int ret, len;
521 const uint8_t *buf = _buf;
522
523 len = len1;
524 while (len > 0) {
525 ret = write(fd, buf, len);
526 if (ret < 0) {
527 if (errno != EINTR && errno != EAGAIN)
528 return -1;
529 } else if (ret == 0) {
530 break;
531 } else {
532 buf += ret;
533 len -= ret;
534 }
535 }
536 return len1 - len;
537 }
538 #endif /* !_WIN32 */
539
540 #define STDIO_MAX_CLIENTS 1
541 static int stdio_nb_clients;
542
543 #ifndef _WIN32
544
545 typedef struct {
546 int fd_in, fd_out;
547 int max_size;
548 } FDCharDriver;
549
550
551 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
552 {
553 FDCharDriver *s = chr->opaque;
554 return send_all(s->fd_out, buf, len);
555 }
556
557 static int fd_chr_read_poll(void *opaque)
558 {
559 CharDriverState *chr = opaque;
560 FDCharDriver *s = chr->opaque;
561
562 s->max_size = qemu_chr_be_can_write(chr);
563 return s->max_size;
564 }
565
566 static void fd_chr_read(void *opaque)
567 {
568 CharDriverState *chr = opaque;
569 FDCharDriver *s = chr->opaque;
570 int size, len;
571 uint8_t buf[READ_BUF_LEN];
572
573 len = sizeof(buf);
574 if (len > s->max_size)
575 len = s->max_size;
576 if (len == 0)
577 return;
578 size = read(s->fd_in, buf, len);
579 if (size == 0) {
580 /* FD has been closed. Remove it from the active list. */
581 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
582 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
583 return;
584 }
585 if (size > 0) {
586 qemu_chr_be_write(chr, buf, size);
587 }
588 }
589
590 static void fd_chr_update_read_handler(CharDriverState *chr)
591 {
592 FDCharDriver *s = chr->opaque;
593
594 if (s->fd_in >= 0) {
595 if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
596 } else {
597 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
598 fd_chr_read, NULL, chr);
599 }
600 }
601 }
602
603 static void fd_chr_close(struct CharDriverState *chr)
604 {
605 FDCharDriver *s = chr->opaque;
606
607 if (s->fd_in >= 0) {
608 if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
609 } else {
610 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
611 }
612 }
613
614 g_free(s);
615 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
616 }
617
618 /* open a character device to a unix fd */
619 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
620 {
621 CharDriverState *chr;
622 FDCharDriver *s;
623
624 chr = g_malloc0(sizeof(CharDriverState));
625 s = g_malloc0(sizeof(FDCharDriver));
626 s->fd_in = fd_in;
627 s->fd_out = fd_out;
628 chr->opaque = s;
629 chr->chr_write = fd_chr_write;
630 chr->chr_update_read_handler = fd_chr_update_read_handler;
631 chr->chr_close = fd_chr_close;
632
633 qemu_chr_generic_open(chr);
634
635 return chr;
636 }
637
638 static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
639 {
640 int fd_out;
641
642 TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),
643 O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
644 if (fd_out < 0) {
645 return NULL;
646 }
647 return qemu_chr_open_fd(-1, fd_out);
648 }
649
650 static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
651 {
652 int fd_in, fd_out;
653 char filename_in[256], filename_out[256];
654 const char *filename = qemu_opt_get(opts, "path");
655
656 if (filename == NULL) {
657 fprintf(stderr, "chardev: pipe: no filename given\n");
658 return NULL;
659 }
660
661 snprintf(filename_in, 256, "%s.in", filename);
662 snprintf(filename_out, 256, "%s.out", filename);
663 TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
664 TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
665 if (fd_in < 0 || fd_out < 0) {
666 if (fd_in >= 0)
667 close(fd_in);
668 if (fd_out >= 0)
669 close(fd_out);
670 TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
671 if (fd_in < 0) {
672 return NULL;
673 }
674 }
675 return qemu_chr_open_fd(fd_in, fd_out);
676 }
677
678
679 /* for STDIO, we handle the case where several clients use it
680 (nographic mode) */
681
682 #define TERM_FIFO_MAX_SIZE 1
683
684 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
685 static int term_fifo_size;
686
687 static int stdio_read_poll(void *opaque)
688 {
689 CharDriverState *chr = opaque;
690
691 /* try to flush the queue if needed */
692 if (term_fifo_size != 0 && qemu_chr_be_can_write(chr) > 0) {
693 qemu_chr_be_write(chr, term_fifo, 1);
694 term_fifo_size = 0;
695 }
696 /* see if we can absorb more chars */
697 if (term_fifo_size == 0)
698 return 1;
699 else
700 return 0;
701 }
702
703 static void stdio_read(void *opaque)
704 {
705 int size;
706 uint8_t buf[1];
707 CharDriverState *chr = opaque;
708
709 size = read(0, buf, 1);
710 if (size == 0) {
711 /* stdin has been closed. Remove it from the active list. */
712 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
713 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
714 return;
715 }
716 if (size > 0) {
717 if (qemu_chr_be_can_write(chr) > 0) {
718 qemu_chr_be_write(chr, buf, 1);
719 } else if (term_fifo_size == 0) {
720 term_fifo[term_fifo_size++] = buf[0];
721 }
722 }
723 }
724
725 /* init terminal so that we can grab keys */
726 static struct termios oldtty;
727 static int old_fd0_flags;
728 static bool stdio_allow_signal;
729
730 static void term_exit(void)
731 {
732 tcsetattr (0, TCSANOW, &oldtty);
733 fcntl(0, F_SETFL, old_fd0_flags);
734 }
735
736 static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo)
737 {
738 struct termios tty;
739
740 tty = oldtty;
741 if (!echo) {
742 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
743 |INLCR|IGNCR|ICRNL|IXON);
744 tty.c_oflag |= OPOST;
745 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
746 tty.c_cflag &= ~(CSIZE|PARENB);
747 tty.c_cflag |= CS8;
748 tty.c_cc[VMIN] = 1;
749 tty.c_cc[VTIME] = 0;
750 }
751 /* if graphical mode, we allow Ctrl-C handling */
752 if (!stdio_allow_signal)
753 tty.c_lflag &= ~ISIG;
754
755 tcsetattr (0, TCSANOW, &tty);
756 }
757
758 static void qemu_chr_close_stdio(struct CharDriverState *chr)
759 {
760 term_exit();
761 stdio_nb_clients--;
762 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
763 fd_chr_close(chr);
764 }
765
766 static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
767 {
768 CharDriverState *chr;
769
770 if (stdio_nb_clients >= STDIO_MAX_CLIENTS) {
771 return NULL;
772 }
773 if (stdio_nb_clients == 0) {
774 old_fd0_flags = fcntl(0, F_GETFL);
775 tcgetattr (0, &oldtty);
776 fcntl(0, F_SETFL, O_NONBLOCK);
777 atexit(term_exit);
778 }
779
780 chr = qemu_chr_open_fd(0, 1);
781 chr->chr_close = qemu_chr_close_stdio;
782 chr->chr_set_echo = qemu_chr_set_echo_stdio;
783 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
784 stdio_nb_clients++;
785 stdio_allow_signal = qemu_opt_get_bool(opts, "signal",
786 display_type != DT_NOGRAPHIC);
787 qemu_chr_fe_set_echo(chr, false);
788
789 return chr;
790 }
791
792 #ifdef __sun__
793 /* Once Solaris has openpty(), this is going to be removed. */
794 static int openpty(int *amaster, int *aslave, char *name,
795 struct termios *termp, struct winsize *winp)
796 {
797 const char *slave;
798 int mfd = -1, sfd = -1;
799
800 *amaster = *aslave = -1;
801
802 mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
803 if (mfd < 0)
804 goto err;
805
806 if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
807 goto err;
808
809 if ((slave = ptsname(mfd)) == NULL)
810 goto err;
811
812 if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
813 goto err;
814
815 if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
816 (termp != NULL && tcgetattr(sfd, termp) < 0))
817 goto err;
818
819 if (amaster)
820 *amaster = mfd;
821 if (aslave)
822 *aslave = sfd;
823 if (winp)
824 ioctl(sfd, TIOCSWINSZ, winp);
825
826 return 0;
827
828 err:
829 if (sfd != -1)
830 close(sfd);
831 close(mfd);
832 return -1;
833 }
834
835 static void cfmakeraw (struct termios *termios_p)
836 {
837 termios_p->c_iflag &=
838 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
839 termios_p->c_oflag &= ~OPOST;
840 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
841 termios_p->c_cflag &= ~(CSIZE|PARENB);
842 termios_p->c_cflag |= CS8;
843
844 termios_p->c_cc[VMIN] = 0;
845 termios_p->c_cc[VTIME] = 0;
846 }
847 #endif
848
849 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
850 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
851 || defined(__GLIBC__)
852
853 typedef struct {
854 int fd;
855 int connected;
856 int polling;
857 int read_bytes;
858 QEMUTimer *timer;
859 } PtyCharDriver;
860
861 static void pty_chr_update_read_handler(CharDriverState *chr);
862 static void pty_chr_state(CharDriverState *chr, int connected);
863
864 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
865 {
866 PtyCharDriver *s = chr->opaque;
867
868 if (!s->connected) {
869 /* guest sends data, check for (re-)connect */
870 pty_chr_update_read_handler(chr);
871 return 0;
872 }
873 return send_all(s->fd, buf, len);
874 }
875
876 static int pty_chr_read_poll(void *opaque)
877 {
878 CharDriverState *chr = opaque;
879 PtyCharDriver *s = chr->opaque;
880
881 s->read_bytes = qemu_chr_be_can_write(chr);
882 return s->read_bytes;
883 }
884
885 static void pty_chr_read(void *opaque)
886 {
887 CharDriverState *chr = opaque;
888 PtyCharDriver *s = chr->opaque;
889 int size, len;
890 uint8_t buf[READ_BUF_LEN];
891
892 len = sizeof(buf);
893 if (len > s->read_bytes)
894 len = s->read_bytes;
895 if (len == 0)
896 return;
897 size = read(s->fd, buf, len);
898 if ((size == -1 && errno == EIO) ||
899 (size == 0)) {
900 pty_chr_state(chr, 0);
901 return;
902 }
903 if (size > 0) {
904 pty_chr_state(chr, 1);
905 qemu_chr_be_write(chr, buf, size);
906 }
907 }
908
909 static void pty_chr_update_read_handler(CharDriverState *chr)
910 {
911 PtyCharDriver *s = chr->opaque;
912
913 qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
914 pty_chr_read, NULL, chr);
915 s->polling = 1;
916 /*
917 * Short timeout here: just need wait long enougth that qemu makes
918 * it through the poll loop once. When reconnected we want a
919 * short timeout so we notice it almost instantly. Otherwise
920 * read() gives us -EIO instantly, making pty_chr_state() reset the
921 * timeout to the normal (much longer) poll interval before the
922 * timer triggers.
923 */
924 qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 10);
925 }
926
927 static void pty_chr_state(CharDriverState *chr, int connected)
928 {
929 PtyCharDriver *s = chr->opaque;
930
931 if (!connected) {
932 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
933 s->connected = 0;
934 s->polling = 0;
935 /* (re-)connect poll interval for idle guests: once per second.
936 * We check more frequently in case the guests sends data to
937 * the virtual device linked to our pty. */
938 qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 1000);
939 } else {
940 if (!s->connected)
941 qemu_chr_generic_open(chr);
942 s->connected = 1;
943 }
944 }
945
946 static void pty_chr_timer(void *opaque)
947 {
948 struct CharDriverState *chr = opaque;
949 PtyCharDriver *s = chr->opaque;
950
951 if (s->connected)
952 return;
953 if (s->polling) {
954 /* If we arrive here without polling being cleared due
955 * read returning -EIO, then we are (re-)connected */
956 pty_chr_state(chr, 1);
957 return;
958 }
959
960 /* Next poll ... */
961 pty_chr_update_read_handler(chr);
962 }
963
964 static void pty_chr_close(struct CharDriverState *chr)
965 {
966 PtyCharDriver *s = chr->opaque;
967
968 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
969 close(s->fd);
970 qemu_del_timer(s->timer);
971 qemu_free_timer(s->timer);
972 g_free(s);
973 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
974 }
975
976 static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
977 {
978 CharDriverState *chr;
979 PtyCharDriver *s;
980 struct termios tty;
981 int master_fd, slave_fd, len;
982 #if defined(__OpenBSD__) || defined(__DragonFly__)
983 char pty_name[PATH_MAX];
984 #define q_ptsname(x) pty_name
985 #else
986 char *pty_name = NULL;
987 #define q_ptsname(x) ptsname(x)
988 #endif
989
990 if (openpty(&master_fd, &slave_fd, pty_name, NULL, NULL) < 0) {
991 return NULL;
992 }
993
994 /* Set raw attributes on the pty. */
995 tcgetattr(slave_fd, &tty);
996 cfmakeraw(&tty);
997 tcsetattr(slave_fd, TCSAFLUSH, &tty);
998 close(slave_fd);
999
1000 chr = g_malloc0(sizeof(CharDriverState));
1001
1002 len = strlen(q_ptsname(master_fd)) + 5;
1003 chr->filename = g_malloc(len);
1004 snprintf(chr->filename, len, "pty:%s", q_ptsname(master_fd));
1005 qemu_opt_set(opts, "path", q_ptsname(master_fd));
1006 fprintf(stderr, "char device redirected to %s\n", q_ptsname(master_fd));
1007
1008 s = g_malloc0(sizeof(PtyCharDriver));
1009 chr->opaque = s;
1010 chr->chr_write = pty_chr_write;
1011 chr->chr_update_read_handler = pty_chr_update_read_handler;
1012 chr->chr_close = pty_chr_close;
1013
1014 s->fd = master_fd;
1015 s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
1016
1017 return chr;
1018 }
1019
1020 static void tty_serial_init(int fd, int speed,
1021 int parity, int data_bits, int stop_bits)
1022 {
1023 struct termios tty;
1024 speed_t spd;
1025
1026 #if 0
1027 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1028 speed, parity, data_bits, stop_bits);
1029 #endif
1030 tcgetattr (fd, &tty);
1031
1032 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
1033 speed = speed * 10 / 11;
1034 do {
1035 check_speed(50);
1036 check_speed(75);
1037 check_speed(110);
1038 check_speed(134);
1039 check_speed(150);
1040 check_speed(200);
1041 check_speed(300);
1042 check_speed(600);
1043 check_speed(1200);
1044 check_speed(1800);
1045 check_speed(2400);
1046 check_speed(4800);
1047 check_speed(9600);
1048 check_speed(19200);
1049 check_speed(38400);
1050 /* Non-Posix values follow. They may be unsupported on some systems. */
1051 check_speed(57600);
1052 check_speed(115200);
1053 #ifdef B230400
1054 check_speed(230400);
1055 #endif
1056 #ifdef B460800
1057 check_speed(460800);
1058 #endif
1059 #ifdef B500000
1060 check_speed(500000);
1061 #endif
1062 #ifdef B576000
1063 check_speed(576000);
1064 #endif
1065 #ifdef B921600
1066 check_speed(921600);
1067 #endif
1068 #ifdef B1000000
1069 check_speed(1000000);
1070 #endif
1071 #ifdef B1152000
1072 check_speed(1152000);
1073 #endif
1074 #ifdef B1500000
1075 check_speed(1500000);
1076 #endif
1077 #ifdef B2000000
1078 check_speed(2000000);
1079 #endif
1080 #ifdef B2500000
1081 check_speed(2500000);
1082 #endif
1083 #ifdef B3000000
1084 check_speed(3000000);
1085 #endif
1086 #ifdef B3500000
1087 check_speed(3500000);
1088 #endif
1089 #ifdef B4000000
1090 check_speed(4000000);
1091 #endif
1092 spd = B115200;
1093 } while (0);
1094
1095 cfsetispeed(&tty, spd);
1096 cfsetospeed(&tty, spd);
1097
1098 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1099 |INLCR|IGNCR|ICRNL|IXON);
1100 tty.c_oflag |= OPOST;
1101 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1102 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1103 switch(data_bits) {
1104 default:
1105 case 8:
1106 tty.c_cflag |= CS8;
1107 break;
1108 case 7:
1109 tty.c_cflag |= CS7;
1110 break;
1111 case 6:
1112 tty.c_cflag |= CS6;
1113 break;
1114 case 5:
1115 tty.c_cflag |= CS5;
1116 break;
1117 }
1118 switch(parity) {
1119 default:
1120 case 'N':
1121 break;
1122 case 'E':
1123 tty.c_cflag |= PARENB;
1124 break;
1125 case 'O':
1126 tty.c_cflag |= PARENB | PARODD;
1127 break;
1128 }
1129 if (stop_bits == 2)
1130 tty.c_cflag |= CSTOPB;
1131
1132 tcsetattr (fd, TCSANOW, &tty);
1133 }
1134
1135 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1136 {
1137 FDCharDriver *s = chr->opaque;
1138
1139 switch(cmd) {
1140 case CHR_IOCTL_SERIAL_SET_PARAMS:
1141 {
1142 QEMUSerialSetParams *ssp = arg;
1143 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1144 ssp->data_bits, ssp->stop_bits);
1145 }
1146 break;
1147 case CHR_IOCTL_SERIAL_SET_BREAK:
1148 {
1149 int enable = *(int *)arg;
1150 if (enable)
1151 tcsendbreak(s->fd_in, 1);
1152 }
1153 break;
1154 case CHR_IOCTL_SERIAL_GET_TIOCM:
1155 {
1156 int sarg = 0;
1157 int *targ = (int *)arg;
1158 ioctl(s->fd_in, TIOCMGET, &sarg);
1159 *targ = 0;
1160 if (sarg & TIOCM_CTS)
1161 *targ |= CHR_TIOCM_CTS;
1162 if (sarg & TIOCM_CAR)
1163 *targ |= CHR_TIOCM_CAR;
1164 if (sarg & TIOCM_DSR)
1165 *targ |= CHR_TIOCM_DSR;
1166 if (sarg & TIOCM_RI)
1167 *targ |= CHR_TIOCM_RI;
1168 if (sarg & TIOCM_DTR)
1169 *targ |= CHR_TIOCM_DTR;
1170 if (sarg & TIOCM_RTS)
1171 *targ |= CHR_TIOCM_RTS;
1172 }
1173 break;
1174 case CHR_IOCTL_SERIAL_SET_TIOCM:
1175 {
1176 int sarg = *(int *)arg;
1177 int targ = 0;
1178 ioctl(s->fd_in, TIOCMGET, &targ);
1179 targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
1180 | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
1181 if (sarg & CHR_TIOCM_CTS)
1182 targ |= TIOCM_CTS;
1183 if (sarg & CHR_TIOCM_CAR)
1184 targ |= TIOCM_CAR;
1185 if (sarg & CHR_TIOCM_DSR)
1186 targ |= TIOCM_DSR;
1187 if (sarg & CHR_TIOCM_RI)
1188 targ |= TIOCM_RI;
1189 if (sarg & CHR_TIOCM_DTR)
1190 targ |= TIOCM_DTR;
1191 if (sarg & CHR_TIOCM_RTS)
1192 targ |= TIOCM_RTS;
1193 ioctl(s->fd_in, TIOCMSET, &targ);
1194 }
1195 break;
1196 default:
1197 return -ENOTSUP;
1198 }
1199 return 0;
1200 }
1201
1202 static void qemu_chr_close_tty(CharDriverState *chr)
1203 {
1204 FDCharDriver *s = chr->opaque;
1205 int fd = -1;
1206
1207 if (s) {
1208 fd = s->fd_in;
1209 }
1210
1211 fd_chr_close(chr);
1212
1213 if (fd >= 0) {
1214 close(fd);
1215 }
1216 }
1217
1218 static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
1219 {
1220 const char *filename = qemu_opt_get(opts, "path");
1221 CharDriverState *chr;
1222 int fd;
1223
1224 TFR(fd = qemu_open(filename, O_RDWR | O_NONBLOCK));
1225 if (fd < 0) {
1226 return NULL;
1227 }
1228 tty_serial_init(fd, 115200, 'N', 8, 1);
1229 chr = qemu_chr_open_fd(fd, fd);
1230 chr->chr_ioctl = tty_serial_ioctl;
1231 chr->chr_close = qemu_chr_close_tty;
1232 return chr;
1233 }
1234 #else /* ! __linux__ && ! __sun__ */
1235 static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
1236 {
1237 return NULL;
1238 }
1239 #endif /* __linux__ || __sun__ */
1240
1241 #if defined(__linux__)
1242 typedef struct {
1243 int fd;
1244 int mode;
1245 } ParallelCharDriver;
1246
1247 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
1248 {
1249 if (s->mode != mode) {
1250 int m = mode;
1251 if (ioctl(s->fd, PPSETMODE, &m) < 0)
1252 return 0;
1253 s->mode = mode;
1254 }
1255 return 1;
1256 }
1257
1258 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1259 {
1260 ParallelCharDriver *drv = chr->opaque;
1261 int fd = drv->fd;
1262 uint8_t b;
1263
1264 switch(cmd) {
1265 case CHR_IOCTL_PP_READ_DATA:
1266 if (ioctl(fd, PPRDATA, &b) < 0)
1267 return -ENOTSUP;
1268 *(uint8_t *)arg = b;
1269 break;
1270 case CHR_IOCTL_PP_WRITE_DATA:
1271 b = *(uint8_t *)arg;
1272 if (ioctl(fd, PPWDATA, &b) < 0)
1273 return -ENOTSUP;
1274 break;
1275 case CHR_IOCTL_PP_READ_CONTROL:
1276 if (ioctl(fd, PPRCONTROL, &b) < 0)
1277 return -ENOTSUP;
1278 /* Linux gives only the lowest bits, and no way to know data
1279 direction! For better compatibility set the fixed upper
1280 bits. */
1281 *(uint8_t *)arg = b | 0xc0;
1282 break;
1283 case CHR_IOCTL_PP_WRITE_CONTROL:
1284 b = *(uint8_t *)arg;
1285 if (ioctl(fd, PPWCONTROL, &b) < 0)
1286 return -ENOTSUP;
1287 break;
1288 case CHR_IOCTL_PP_READ_STATUS:
1289 if (ioctl(fd, PPRSTATUS, &b) < 0)
1290 return -ENOTSUP;
1291 *(uint8_t *)arg = b;
1292 break;
1293 case CHR_IOCTL_PP_DATA_DIR:
1294 if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
1295 return -ENOTSUP;
1296 break;
1297 case CHR_IOCTL_PP_EPP_READ_ADDR:
1298 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1299 struct ParallelIOArg *parg = arg;
1300 int n = read(fd, parg->buffer, parg->count);
1301 if (n != parg->count) {
1302 return -EIO;
1303 }
1304 }
1305 break;
1306 case CHR_IOCTL_PP_EPP_READ:
1307 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1308 struct ParallelIOArg *parg = arg;
1309 int n = read(fd, parg->buffer, parg->count);
1310 if (n != parg->count) {
1311 return -EIO;
1312 }
1313 }
1314 break;
1315 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
1316 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1317 struct ParallelIOArg *parg = arg;
1318 int n = write(fd, parg->buffer, parg->count);
1319 if (n != parg->count) {
1320 return -EIO;
1321 }
1322 }
1323 break;
1324 case CHR_IOCTL_PP_EPP_WRITE:
1325 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1326 struct ParallelIOArg *parg = arg;
1327 int n = write(fd, parg->buffer, parg->count);
1328 if (n != parg->count) {
1329 return -EIO;
1330 }
1331 }
1332 break;
1333 default:
1334 return -ENOTSUP;
1335 }
1336 return 0;
1337 }
1338
1339 static void pp_close(CharDriverState *chr)
1340 {
1341 ParallelCharDriver *drv = chr->opaque;
1342 int fd = drv->fd;
1343
1344 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
1345 ioctl(fd, PPRELEASE);
1346 close(fd);
1347 g_free(drv);
1348 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1349 }
1350
1351 static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1352 {
1353 const char *filename = qemu_opt_get(opts, "path");
1354 CharDriverState *chr;
1355 ParallelCharDriver *drv;
1356 int fd;
1357
1358 TFR(fd = qemu_open(filename, O_RDWR));
1359 if (fd < 0) {
1360 return NULL;
1361 }
1362
1363 if (ioctl(fd, PPCLAIM) < 0) {
1364 close(fd);
1365 return NULL;
1366 }
1367
1368 drv = g_malloc0(sizeof(ParallelCharDriver));
1369 drv->fd = fd;
1370 drv->mode = IEEE1284_MODE_COMPAT;
1371
1372 chr = g_malloc0(sizeof(CharDriverState));
1373 chr->chr_write = null_chr_write;
1374 chr->chr_ioctl = pp_ioctl;
1375 chr->chr_close = pp_close;
1376 chr->opaque = drv;
1377
1378 qemu_chr_generic_open(chr);
1379
1380 return chr;
1381 }
1382 #endif /* __linux__ */
1383
1384 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1385 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1386 {
1387 int fd = (int)(intptr_t)chr->opaque;
1388 uint8_t b;
1389
1390 switch(cmd) {
1391 case CHR_IOCTL_PP_READ_DATA:
1392 if (ioctl(fd, PPIGDATA, &b) < 0)
1393 return -ENOTSUP;
1394 *(uint8_t *)arg = b;
1395 break;
1396 case CHR_IOCTL_PP_WRITE_DATA:
1397 b = *(uint8_t *)arg;
1398 if (ioctl(fd, PPISDATA, &b) < 0)
1399 return -ENOTSUP;
1400 break;
1401 case CHR_IOCTL_PP_READ_CONTROL:
1402 if (ioctl(fd, PPIGCTRL, &b) < 0)
1403 return -ENOTSUP;
1404 *(uint8_t *)arg = b;
1405 break;
1406 case CHR_IOCTL_PP_WRITE_CONTROL:
1407 b = *(uint8_t *)arg;
1408 if (ioctl(fd, PPISCTRL, &b) < 0)
1409 return -ENOTSUP;
1410 break;
1411 case CHR_IOCTL_PP_READ_STATUS:
1412 if (ioctl(fd, PPIGSTATUS, &b) < 0)
1413 return -ENOTSUP;
1414 *(uint8_t *)arg = b;
1415 break;
1416 default:
1417 return -ENOTSUP;
1418 }
1419 return 0;
1420 }
1421
1422 static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1423 {
1424 const char *filename = qemu_opt_get(opts, "path");
1425 CharDriverState *chr;
1426 int fd;
1427
1428 fd = qemu_open(filename, O_RDWR);
1429 if (fd < 0) {
1430 return NULL;
1431 }
1432
1433 chr = g_malloc0(sizeof(CharDriverState));
1434 chr->opaque = (void *)(intptr_t)fd;
1435 chr->chr_write = null_chr_write;
1436 chr->chr_ioctl = pp_ioctl;
1437 return chr;
1438 }
1439 #endif
1440
1441 #else /* _WIN32 */
1442
1443 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1444
1445 typedef struct {
1446 int max_size;
1447 HANDLE hcom, hrecv, hsend;
1448 OVERLAPPED orecv, osend;
1449 BOOL fpipe;
1450 DWORD len;
1451 } WinCharState;
1452
1453 typedef struct {
1454 HANDLE hStdIn;
1455 HANDLE hInputReadyEvent;
1456 HANDLE hInputDoneEvent;
1457 HANDLE hInputThread;
1458 uint8_t win_stdio_buf;
1459 } WinStdioCharState;
1460
1461 #define NSENDBUF 2048
1462 #define NRECVBUF 2048
1463 #define MAXCONNECT 1
1464 #define NTIMEOUT 5000
1465
1466 static int win_chr_poll(void *opaque);
1467 static int win_chr_pipe_poll(void *opaque);
1468
1469 static void win_chr_close(CharDriverState *chr)
1470 {
1471 WinCharState *s = chr->opaque;
1472
1473 if (s->hsend) {
1474 CloseHandle(s->hsend);
1475 s->hsend = NULL;
1476 }
1477 if (s->hrecv) {
1478 CloseHandle(s->hrecv);
1479 s->hrecv = NULL;
1480 }
1481 if (s->hcom) {
1482 CloseHandle(s->hcom);
1483 s->hcom = NULL;
1484 }
1485 if (s->fpipe)
1486 qemu_del_polling_cb(win_chr_pipe_poll, chr);
1487 else
1488 qemu_del_polling_cb(win_chr_poll, chr);
1489
1490 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1491 }
1492
1493 static int win_chr_init(CharDriverState *chr, const char *filename)
1494 {
1495 WinCharState *s = chr->opaque;
1496 COMMCONFIG comcfg;
1497 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1498 COMSTAT comstat;
1499 DWORD size;
1500 DWORD err;
1501
1502 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1503 if (!s->hsend) {
1504 fprintf(stderr, "Failed CreateEvent\n");
1505 goto fail;
1506 }
1507 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1508 if (!s->hrecv) {
1509 fprintf(stderr, "Failed CreateEvent\n");
1510 goto fail;
1511 }
1512
1513 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1514 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1515 if (s->hcom == INVALID_HANDLE_VALUE) {
1516 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1517 s->hcom = NULL;
1518 goto fail;
1519 }
1520
1521 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1522 fprintf(stderr, "Failed SetupComm\n");
1523 goto fail;
1524 }
1525
1526 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1527 size = sizeof(COMMCONFIG);
1528 GetDefaultCommConfig(filename, &comcfg, &size);
1529 comcfg.dcb.DCBlength = sizeof(DCB);
1530 CommConfigDialog(filename, NULL, &comcfg);
1531
1532 if (!SetCommState(s->hcom, &comcfg.dcb)) {
1533 fprintf(stderr, "Failed SetCommState\n");
1534 goto fail;
1535 }
1536
1537 if (!SetCommMask(s->hcom, EV_ERR)) {
1538 fprintf(stderr, "Failed SetCommMask\n");
1539 goto fail;
1540 }
1541
1542 cto.ReadIntervalTimeout = MAXDWORD;
1543 if (!SetCommTimeouts(s->hcom, &cto)) {
1544 fprintf(stderr, "Failed SetCommTimeouts\n");
1545 goto fail;
1546 }
1547
1548 if (!ClearCommError(s->hcom, &err, &comstat)) {
1549 fprintf(stderr, "Failed ClearCommError\n");
1550 goto fail;
1551 }
1552 qemu_add_polling_cb(win_chr_poll, chr);
1553 return 0;
1554
1555 fail:
1556 win_chr_close(chr);
1557 return -1;
1558 }
1559
1560 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1561 {
1562 WinCharState *s = chr->opaque;
1563 DWORD len, ret, size, err;
1564
1565 len = len1;
1566 ZeroMemory(&s->osend, sizeof(s->osend));
1567 s->osend.hEvent = s->hsend;
1568 while (len > 0) {
1569 if (s->hsend)
1570 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1571 else
1572 ret = WriteFile(s->hcom, buf, len, &size, NULL);
1573 if (!ret) {
1574 err = GetLastError();
1575 if (err == ERROR_IO_PENDING) {
1576 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1577 if (ret) {
1578 buf += size;
1579 len -= size;
1580 } else {
1581 break;
1582 }
1583 } else {
1584 break;
1585 }
1586 } else {
1587 buf += size;
1588 len -= size;
1589 }
1590 }
1591 return len1 - len;
1592 }
1593
1594 static int win_chr_read_poll(CharDriverState *chr)
1595 {
1596 WinCharState *s = chr->opaque;
1597
1598 s->max_size = qemu_chr_be_can_write(chr);
1599 return s->max_size;
1600 }
1601
1602 static void win_chr_readfile(CharDriverState *chr)
1603 {
1604 WinCharState *s = chr->opaque;
1605 int ret, err;
1606 uint8_t buf[READ_BUF_LEN];
1607 DWORD size;
1608
1609 ZeroMemory(&s->orecv, sizeof(s->orecv));
1610 s->orecv.hEvent = s->hrecv;
1611 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1612 if (!ret) {
1613 err = GetLastError();
1614 if (err == ERROR_IO_PENDING) {
1615 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1616 }
1617 }
1618
1619 if (size > 0) {
1620 qemu_chr_be_write(chr, buf, size);
1621 }
1622 }
1623
1624 static void win_chr_read(CharDriverState *chr)
1625 {
1626 WinCharState *s = chr->opaque;
1627
1628 if (s->len > s->max_size)
1629 s->len = s->max_size;
1630 if (s->len == 0)
1631 return;
1632
1633 win_chr_readfile(chr);
1634 }
1635
1636 static int win_chr_poll(void *opaque)
1637 {
1638 CharDriverState *chr = opaque;
1639 WinCharState *s = chr->opaque;
1640 COMSTAT status;
1641 DWORD comerr;
1642
1643 ClearCommError(s->hcom, &comerr, &status);
1644 if (status.cbInQue > 0) {
1645 s->len = status.cbInQue;
1646 win_chr_read_poll(chr);
1647 win_chr_read(chr);
1648 return 1;
1649 }
1650 return 0;
1651 }
1652
1653 static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
1654 {
1655 const char *filename = qemu_opt_get(opts, "path");
1656 CharDriverState *chr;
1657 WinCharState *s;
1658
1659 chr = g_malloc0(sizeof(CharDriverState));
1660 s = g_malloc0(sizeof(WinCharState));
1661 chr->opaque = s;
1662 chr->chr_write = win_chr_write;
1663 chr->chr_close = win_chr_close;
1664
1665 if (win_chr_init(chr, filename) < 0) {
1666 g_free(s);
1667 g_free(chr);
1668 return NULL;
1669 }
1670 qemu_chr_generic_open(chr);
1671 return chr;
1672 }
1673
1674 static int win_chr_pipe_poll(void *opaque)
1675 {
1676 CharDriverState *chr = opaque;
1677 WinCharState *s = chr->opaque;
1678 DWORD size;
1679
1680 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
1681 if (size > 0) {
1682 s->len = size;
1683 win_chr_read_poll(chr);
1684 win_chr_read(chr);
1685 return 1;
1686 }
1687 return 0;
1688 }
1689
1690 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1691 {
1692 WinCharState *s = chr->opaque;
1693 OVERLAPPED ov;
1694 int ret;
1695 DWORD size;
1696 char openname[256];
1697
1698 s->fpipe = TRUE;
1699
1700 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1701 if (!s->hsend) {
1702 fprintf(stderr, "Failed CreateEvent\n");
1703 goto fail;
1704 }
1705 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1706 if (!s->hrecv) {
1707 fprintf(stderr, "Failed CreateEvent\n");
1708 goto fail;
1709 }
1710
1711 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
1712 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
1713 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
1714 PIPE_WAIT,
1715 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
1716 if (s->hcom == INVALID_HANDLE_VALUE) {
1717 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
1718 s->hcom = NULL;
1719 goto fail;
1720 }
1721
1722 ZeroMemory(&ov, sizeof(ov));
1723 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1724 ret = ConnectNamedPipe(s->hcom, &ov);
1725 if (ret) {
1726 fprintf(stderr, "Failed ConnectNamedPipe\n");
1727 goto fail;
1728 }
1729
1730 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
1731 if (!ret) {
1732 fprintf(stderr, "Failed GetOverlappedResult\n");
1733 if (ov.hEvent) {
1734 CloseHandle(ov.hEvent);
1735 ov.hEvent = NULL;
1736 }
1737 goto fail;
1738 }
1739
1740 if (ov.hEvent) {
1741 CloseHandle(ov.hEvent);
1742 ov.hEvent = NULL;
1743 }
1744 qemu_add_polling_cb(win_chr_pipe_poll, chr);
1745 return 0;
1746
1747 fail:
1748 win_chr_close(chr);
1749 return -1;
1750 }
1751
1752
1753 static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
1754 {
1755 const char *filename = qemu_opt_get(opts, "path");
1756 CharDriverState *chr;
1757 WinCharState *s;
1758
1759 chr = g_malloc0(sizeof(CharDriverState));
1760 s = g_malloc0(sizeof(WinCharState));
1761 chr->opaque = s;
1762 chr->chr_write = win_chr_write;
1763 chr->chr_close = win_chr_close;
1764
1765 if (win_chr_pipe_init(chr, filename) < 0) {
1766 g_free(s);
1767 g_free(chr);
1768 return NULL;
1769 }
1770 qemu_chr_generic_open(chr);
1771 return chr;
1772 }
1773
1774 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
1775 {
1776 CharDriverState *chr;
1777 WinCharState *s;
1778
1779 chr = g_malloc0(sizeof(CharDriverState));
1780 s = g_malloc0(sizeof(WinCharState));
1781 s->hcom = fd_out;
1782 chr->opaque = s;
1783 chr->chr_write = win_chr_write;
1784 qemu_chr_generic_open(chr);
1785 return chr;
1786 }
1787
1788 static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
1789 {
1790 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
1791 }
1792
1793 static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
1794 {
1795 const char *file_out = qemu_opt_get(opts, "path");
1796 HANDLE fd_out;
1797
1798 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1799 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1800 if (fd_out == INVALID_HANDLE_VALUE) {
1801 return NULL;
1802 }
1803
1804 return qemu_chr_open_win_file(fd_out);
1805 }
1806
1807 static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
1808 {
1809 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
1810 DWORD dwSize;
1811 int len1;
1812
1813 len1 = len;
1814
1815 while (len1 > 0) {
1816 if (!WriteFile(hStdOut, buf, len1, &dwSize, NULL)) {
1817 break;
1818 }
1819 buf += dwSize;
1820 len1 -= dwSize;
1821 }
1822
1823 return len - len1;
1824 }
1825
1826 static void win_stdio_wait_func(void *opaque)
1827 {
1828 CharDriverState *chr = opaque;
1829 WinStdioCharState *stdio = chr->opaque;
1830 INPUT_RECORD buf[4];
1831 int ret;
1832 DWORD dwSize;
1833 int i;
1834
1835 ret = ReadConsoleInput(stdio->hStdIn, buf, sizeof(buf) / sizeof(*buf),
1836 &dwSize);
1837
1838 if (!ret) {
1839 /* Avoid error storm */
1840 qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
1841 return;
1842 }
1843
1844 for (i = 0; i < dwSize; i++) {
1845 KEY_EVENT_RECORD *kev = &buf[i].Event.KeyEvent;
1846
1847 if (buf[i].EventType == KEY_EVENT && kev->bKeyDown) {
1848 int j;
1849 if (kev->uChar.AsciiChar != 0) {
1850 for (j = 0; j < kev->wRepeatCount; j++) {
1851 if (qemu_chr_be_can_write(chr)) {
1852 uint8_t c = kev->uChar.AsciiChar;
1853 qemu_chr_be_write(chr, &c, 1);
1854 }
1855 }
1856 }
1857 }
1858 }
1859 }
1860
1861 static DWORD WINAPI win_stdio_thread(LPVOID param)
1862 {
1863 CharDriverState *chr = param;
1864 WinStdioCharState *stdio = chr->opaque;
1865 int ret;
1866 DWORD dwSize;
1867
1868 while (1) {
1869
1870 /* Wait for one byte */
1871 ret = ReadFile(stdio->hStdIn, &stdio->win_stdio_buf, 1, &dwSize, NULL);
1872
1873 /* Exit in case of error, continue if nothing read */
1874 if (!ret) {
1875 break;
1876 }
1877 if (!dwSize) {
1878 continue;
1879 }
1880
1881 /* Some terminal emulator returns \r\n for Enter, just pass \n */
1882 if (stdio->win_stdio_buf == '\r') {
1883 continue;
1884 }
1885
1886 /* Signal the main thread and wait until the byte was eaten */
1887 if (!SetEvent(stdio->hInputReadyEvent)) {
1888 break;
1889 }
1890 if (WaitForSingleObject(stdio->hInputDoneEvent, INFINITE)
1891 != WAIT_OBJECT_0) {
1892 break;
1893 }
1894 }
1895
1896 qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
1897 return 0;
1898 }
1899
1900 static void win_stdio_thread_wait_func(void *opaque)
1901 {
1902 CharDriverState *chr = opaque;
1903 WinStdioCharState *stdio = chr->opaque;
1904
1905 if (qemu_chr_be_can_write(chr)) {
1906 qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
1907 }
1908
1909 SetEvent(stdio->hInputDoneEvent);
1910 }
1911
1912 static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
1913 {
1914 WinStdioCharState *stdio = chr->opaque;
1915 DWORD dwMode = 0;
1916
1917 GetConsoleMode(stdio->hStdIn, &dwMode);
1918
1919 if (echo) {
1920 SetConsoleMode(stdio->hStdIn, dwMode | ENABLE_ECHO_INPUT);
1921 } else {
1922 SetConsoleMode(stdio->hStdIn, dwMode & ~ENABLE_ECHO_INPUT);
1923 }
1924 }
1925
1926 static void win_stdio_close(CharDriverState *chr)
1927 {
1928 WinStdioCharState *stdio = chr->opaque;
1929
1930 if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
1931 CloseHandle(stdio->hInputReadyEvent);
1932 }
1933 if (stdio->hInputDoneEvent != INVALID_HANDLE_VALUE) {
1934 CloseHandle(stdio->hInputDoneEvent);
1935 }
1936 if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
1937 TerminateThread(stdio->hInputThread, 0);
1938 }
1939
1940 g_free(chr->opaque);
1941 g_free(chr);
1942 stdio_nb_clients--;
1943 }
1944
1945 static CharDriverState *qemu_chr_open_win_stdio(QemuOpts *opts)
1946 {
1947 CharDriverState *chr;
1948 WinStdioCharState *stdio;
1949 DWORD dwMode;
1950 int is_console = 0;
1951
1952 if (stdio_nb_clients >= STDIO_MAX_CLIENTS
1953 || ((display_type != DT_NOGRAPHIC) && (stdio_nb_clients != 0))) {
1954 return NULL;
1955 }
1956
1957 chr = g_malloc0(sizeof(CharDriverState));
1958 stdio = g_malloc0(sizeof(WinStdioCharState));
1959
1960 stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
1961 if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
1962 fprintf(stderr, "cannot open stdio: invalid handle\n");
1963 exit(1);
1964 }
1965
1966 is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
1967
1968 chr->opaque = stdio;
1969 chr->chr_write = win_stdio_write;
1970 chr->chr_close = win_stdio_close;
1971
1972 if (stdio_nb_clients == 0) {
1973 if (is_console) {
1974 if (qemu_add_wait_object(stdio->hStdIn,
1975 win_stdio_wait_func, chr)) {
1976 fprintf(stderr, "qemu_add_wait_object: failed\n");
1977 }
1978 } else {
1979 DWORD dwId;
1980
1981 stdio->hInputReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
1982 stdio->hInputDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
1983 stdio->hInputThread = CreateThread(NULL, 0, win_stdio_thread,
1984 chr, 0, &dwId);
1985
1986 if (stdio->hInputThread == INVALID_HANDLE_VALUE
1987 || stdio->hInputReadyEvent == INVALID_HANDLE_VALUE
1988 || stdio->hInputDoneEvent == INVALID_HANDLE_VALUE) {
1989 fprintf(stderr, "cannot create stdio thread or event\n");
1990 exit(1);
1991 }
1992 if (qemu_add_wait_object(stdio->hInputReadyEvent,
1993 win_stdio_thread_wait_func, chr)) {
1994 fprintf(stderr, "qemu_add_wait_object: failed\n");
1995 }
1996 }
1997 }
1998
1999 dwMode |= ENABLE_LINE_INPUT;
2000
2001 stdio_clients[stdio_nb_clients++] = chr;
2002 if (stdio_nb_clients == 1 && is_console) {
2003 /* set the terminal in raw mode */
2004 /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
2005 dwMode |= ENABLE_PROCESSED_INPUT;
2006 }
2007
2008 SetConsoleMode(stdio->hStdIn, dwMode);
2009
2010 chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
2011 qemu_chr_fe_set_echo(chr, false);
2012
2013 return chr;
2014 }
2015 #endif /* !_WIN32 */
2016
2017 /***********************************************************/
2018 /* UDP Net console */
2019
2020 typedef struct {
2021 int fd;
2022 uint8_t buf[READ_BUF_LEN];
2023 int bufcnt;
2024 int bufptr;
2025 int max_size;
2026 } NetCharDriver;
2027
2028 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2029 {
2030 NetCharDriver *s = chr->opaque;
2031
2032 return send(s->fd, (const void *)buf, len, 0);
2033 }
2034
2035 static int udp_chr_read_poll(void *opaque)
2036 {
2037 CharDriverState *chr = opaque;
2038 NetCharDriver *s = chr->opaque;
2039
2040 s->max_size = qemu_chr_be_can_write(chr);
2041
2042 /* If there were any stray characters in the queue process them
2043 * first
2044 */
2045 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2046 qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
2047 s->bufptr++;
2048 s->max_size = qemu_chr_be_can_write(chr);
2049 }
2050 return s->max_size;
2051 }
2052
2053 static void udp_chr_read(void *opaque)
2054 {
2055 CharDriverState *chr = opaque;
2056 NetCharDriver *s = chr->opaque;
2057
2058 if (s->max_size == 0)
2059 return;
2060 s->bufcnt = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
2061 s->bufptr = s->bufcnt;
2062 if (s->bufcnt <= 0)
2063 return;
2064
2065 s->bufptr = 0;
2066 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2067 qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
2068 s->bufptr++;
2069 s->max_size = qemu_chr_be_can_write(chr);
2070 }
2071 }
2072
2073 static void udp_chr_update_read_handler(CharDriverState *chr)
2074 {
2075 NetCharDriver *s = chr->opaque;
2076
2077 if (s->fd >= 0) {
2078 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2079 udp_chr_read, NULL, chr);
2080 }
2081 }
2082
2083 static void udp_chr_close(CharDriverState *chr)
2084 {
2085 NetCharDriver *s = chr->opaque;
2086 if (s->fd >= 0) {
2087 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2088 closesocket(s->fd);
2089 }
2090 g_free(s);
2091 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2092 }
2093
2094 static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
2095 {
2096 CharDriverState *chr = NULL;
2097 NetCharDriver *s = NULL;
2098 int fd = -1;
2099
2100 chr = g_malloc0(sizeof(CharDriverState));
2101 s = g_malloc0(sizeof(NetCharDriver));
2102
2103 fd = inet_dgram_opts(opts);
2104 if (fd < 0) {
2105 fprintf(stderr, "inet_dgram_opts failed\n");
2106 goto return_err;
2107 }
2108
2109 s->fd = fd;
2110 s->bufcnt = 0;
2111 s->bufptr = 0;
2112 chr->opaque = s;
2113 chr->chr_write = udp_chr_write;
2114 chr->chr_update_read_handler = udp_chr_update_read_handler;
2115 chr->chr_close = udp_chr_close;
2116 return chr;
2117
2118 return_err:
2119 g_free(chr);
2120 g_free(s);
2121 if (fd >= 0) {
2122 closesocket(fd);
2123 }
2124 return NULL;
2125 }
2126
2127 /***********************************************************/
2128 /* TCP Net console */
2129
2130 typedef struct {
2131 int fd, listen_fd;
2132 int connected;
2133 int max_size;
2134 int do_telnetopt;
2135 int do_nodelay;
2136 int is_unix;
2137 int msgfd;
2138 } TCPCharDriver;
2139
2140 static void tcp_chr_accept(void *opaque);
2141
2142 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2143 {
2144 TCPCharDriver *s = chr->opaque;
2145 if (s->connected) {
2146 return send_all(s->fd, buf, len);
2147 } else {
2148 /* XXX: indicate an error ? */
2149 return len;
2150 }
2151 }
2152
2153 static int tcp_chr_read_poll(void *opaque)
2154 {
2155 CharDriverState *chr = opaque;
2156 TCPCharDriver *s = chr->opaque;
2157 if (!s->connected)
2158 return 0;
2159 s->max_size = qemu_chr_be_can_write(chr);
2160 return s->max_size;
2161 }
2162
2163 #define IAC 255
2164 #define IAC_BREAK 243
2165 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
2166 TCPCharDriver *s,
2167 uint8_t *buf, int *size)
2168 {
2169 /* Handle any telnet client's basic IAC options to satisfy char by
2170 * char mode with no echo. All IAC options will be removed from
2171 * the buf and the do_telnetopt variable will be used to track the
2172 * state of the width of the IAC information.
2173 *
2174 * IAC commands come in sets of 3 bytes with the exception of the
2175 * "IAC BREAK" command and the double IAC.
2176 */
2177
2178 int i;
2179 int j = 0;
2180
2181 for (i = 0; i < *size; i++) {
2182 if (s->do_telnetopt > 1) {
2183 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
2184 /* Double IAC means send an IAC */
2185 if (j != i)
2186 buf[j] = buf[i];
2187 j++;
2188 s->do_telnetopt = 1;
2189 } else {
2190 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
2191 /* Handle IAC break commands by sending a serial break */
2192 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
2193 s->do_telnetopt++;
2194 }
2195 s->do_telnetopt++;
2196 }
2197 if (s->do_telnetopt >= 4) {
2198 s->do_telnetopt = 1;
2199 }
2200 } else {
2201 if ((unsigned char)buf[i] == IAC) {
2202 s->do_telnetopt = 2;
2203 } else {
2204 if (j != i)
2205 buf[j] = buf[i];
2206 j++;
2207 }
2208 }
2209 }
2210 *size = j;
2211 }
2212
2213 static int tcp_get_msgfd(CharDriverState *chr)
2214 {
2215 TCPCharDriver *s = chr->opaque;
2216 int fd = s->msgfd;
2217 s->msgfd = -1;
2218 return fd;
2219 }
2220
2221 #ifndef _WIN32
2222 static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
2223 {
2224 TCPCharDriver *s = chr->opaque;
2225 struct cmsghdr *cmsg;
2226
2227 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
2228 int fd;
2229
2230 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
2231 cmsg->cmsg_level != SOL_SOCKET ||
2232 cmsg->cmsg_type != SCM_RIGHTS)
2233 continue;
2234
2235 fd = *((int *)CMSG_DATA(cmsg));
2236 if (fd < 0)
2237 continue;
2238
2239 if (s->msgfd != -1)
2240 close(s->msgfd);
2241 s->msgfd = fd;
2242 }
2243 }
2244
2245 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2246 {
2247 TCPCharDriver *s = chr->opaque;
2248 struct msghdr msg = { NULL, };
2249 struct iovec iov[1];
2250 union {
2251 struct cmsghdr cmsg;
2252 char control[CMSG_SPACE(sizeof(int))];
2253 } msg_control;
2254 ssize_t ret;
2255
2256 iov[0].iov_base = buf;
2257 iov[0].iov_len = len;
2258
2259 msg.msg_iov = iov;
2260 msg.msg_iovlen = 1;
2261 msg.msg_control = &msg_control;
2262 msg.msg_controllen = sizeof(msg_control);
2263
2264 ret = recvmsg(s->fd, &msg, 0);
2265 if (ret > 0 && s->is_unix)
2266 unix_process_msgfd(chr, &msg);
2267
2268 return ret;
2269 }
2270 #else
2271 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2272 {
2273 TCPCharDriver *s = chr->opaque;
2274 return qemu_recv(s->fd, buf, len, 0);
2275 }
2276 #endif
2277
2278 static void tcp_chr_read(void *opaque)
2279 {
2280 CharDriverState *chr = opaque;
2281 TCPCharDriver *s = chr->opaque;
2282 uint8_t buf[READ_BUF_LEN];
2283 int len, size;
2284
2285 if (!s->connected || s->max_size <= 0)
2286 return;
2287 len = sizeof(buf);
2288 if (len > s->max_size)
2289 len = s->max_size;
2290 size = tcp_chr_recv(chr, (void *)buf, len);
2291 if (size == 0) {
2292 /* connection closed */
2293 s->connected = 0;
2294 if (s->listen_fd >= 0) {
2295 qemu_set_fd_handler2(s->listen_fd, NULL, tcp_chr_accept, NULL, chr);
2296 }
2297 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2298 closesocket(s->fd);
2299 s->fd = -1;
2300 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2301 } else if (size > 0) {
2302 if (s->do_telnetopt)
2303 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2304 if (size > 0)
2305 qemu_chr_be_write(chr, buf, size);
2306 }
2307 }
2308
2309 #ifndef _WIN32
2310 CharDriverState *qemu_chr_open_eventfd(int eventfd)
2311 {
2312 return qemu_chr_open_fd(eventfd, eventfd);
2313 }
2314 #endif
2315
2316 static void tcp_chr_connect(void *opaque)
2317 {
2318 CharDriverState *chr = opaque;
2319 TCPCharDriver *s = chr->opaque;
2320
2321 s->connected = 1;
2322 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2323 tcp_chr_read, NULL, chr);
2324 qemu_chr_generic_open(chr);
2325 }
2326
2327 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2328 static void tcp_chr_telnet_init(int fd)
2329 {
2330 char buf[3];
2331 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2332 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2333 send(fd, (char *)buf, 3, 0);
2334 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2335 send(fd, (char *)buf, 3, 0);
2336 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
2337 send(fd, (char *)buf, 3, 0);
2338 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
2339 send(fd, (char *)buf, 3, 0);
2340 }
2341
2342 static void socket_set_nodelay(int fd)
2343 {
2344 int val = 1;
2345 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
2346 }
2347
2348 static int tcp_chr_add_client(CharDriverState *chr, int fd)
2349 {
2350 TCPCharDriver *s = chr->opaque;
2351 if (s->fd != -1)
2352 return -1;
2353
2354 socket_set_nonblock(fd);
2355 if (s->do_nodelay)
2356 socket_set_nodelay(fd);
2357 s->fd = fd;
2358 qemu_set_fd_handler2(s->listen_fd, NULL, NULL, NULL, NULL);
2359 tcp_chr_connect(chr);
2360
2361 return 0;
2362 }
2363
2364 static void tcp_chr_accept(void *opaque)
2365 {
2366 CharDriverState *chr = opaque;
2367 TCPCharDriver *s = chr->opaque;
2368 struct sockaddr_in saddr;
2369 #ifndef _WIN32
2370 struct sockaddr_un uaddr;
2371 #endif
2372 struct sockaddr *addr;
2373 socklen_t len;
2374 int fd;
2375
2376 for(;;) {
2377 #ifndef _WIN32
2378 if (s->is_unix) {
2379 len = sizeof(uaddr);
2380 addr = (struct sockaddr *)&uaddr;
2381 } else
2382 #endif
2383 {
2384 len = sizeof(saddr);
2385 addr = (struct sockaddr *)&saddr;
2386 }
2387 fd = qemu_accept(s->listen_fd, addr, &len);
2388 if (fd < 0 && errno != EINTR) {
2389 return;
2390 } else if (fd >= 0) {
2391 if (s->do_telnetopt)
2392 tcp_chr_telnet_init(fd);
2393 break;
2394 }
2395 }
2396 if (tcp_chr_add_client(chr, fd) < 0)
2397 close(fd);
2398 }
2399
2400 static void tcp_chr_close(CharDriverState *chr)
2401 {
2402 TCPCharDriver *s = chr->opaque;
2403 if (s->fd >= 0) {
2404 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2405 closesocket(s->fd);
2406 }
2407 if (s->listen_fd >= 0) {
2408 qemu_set_fd_handler2(s->listen_fd, NULL, NULL, NULL, NULL);
2409 closesocket(s->listen_fd);
2410 }
2411 g_free(s);
2412 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2413 }
2414
2415 static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
2416 {
2417 CharDriverState *chr = NULL;
2418 TCPCharDriver *s = NULL;
2419 int fd = -1;
2420 int is_listen;
2421 int is_waitconnect;
2422 int do_nodelay;
2423 int is_unix;
2424 int is_telnet;
2425
2426 is_listen = qemu_opt_get_bool(opts, "server", 0);
2427 is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
2428 is_telnet = qemu_opt_get_bool(opts, "telnet", 0);
2429 do_nodelay = !qemu_opt_get_bool(opts, "delay", 1);
2430 is_unix = qemu_opt_get(opts, "path") != NULL;
2431 if (!is_listen)
2432 is_waitconnect = 0;
2433
2434 chr = g_malloc0(sizeof(CharDriverState));
2435 s = g_malloc0(sizeof(TCPCharDriver));
2436
2437 if (is_unix) {
2438 if (is_listen) {
2439 fd = unix_listen_opts(opts);
2440 } else {
2441 fd = unix_connect_opts(opts);
2442 }
2443 } else {
2444 if (is_listen) {
2445 fd = inet_listen_opts(opts, 0);
2446 } else {
2447 fd = inet_connect_opts(opts);
2448 }
2449 }
2450 if (fd < 0) {
2451 goto fail;
2452 }
2453
2454 if (!is_waitconnect)
2455 socket_set_nonblock(fd);
2456
2457 s->connected = 0;
2458 s->fd = -1;
2459 s->listen_fd = -1;
2460 s->msgfd = -1;
2461 s->is_unix = is_unix;
2462 s->do_nodelay = do_nodelay && !is_unix;
2463
2464 chr->opaque = s;
2465 chr->chr_write = tcp_chr_write;
2466 chr->chr_close = tcp_chr_close;
2467 chr->get_msgfd = tcp_get_msgfd;
2468 chr->chr_add_client = tcp_chr_add_client;
2469
2470 if (is_listen) {
2471 s->listen_fd = fd;
2472 qemu_set_fd_handler2(s->listen_fd, NULL, tcp_chr_accept, NULL, chr);
2473 if (is_telnet)
2474 s->do_telnetopt = 1;
2475
2476 } else {
2477 s->connected = 1;
2478 s->fd = fd;
2479 socket_set_nodelay(fd);
2480 tcp_chr_connect(chr);
2481 }
2482
2483 /* for "info chardev" monitor command */
2484 chr->filename = g_malloc(256);
2485 if (is_unix) {
2486 snprintf(chr->filename, 256, "unix:%s%s",
2487 qemu_opt_get(opts, "path"),
2488 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2489 } else if (is_telnet) {
2490 snprintf(chr->filename, 256, "telnet:%s:%s%s",
2491 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2492 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2493 } else {
2494 snprintf(chr->filename, 256, "tcp:%s:%s%s",
2495 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2496 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2497 }
2498
2499 if (is_listen && is_waitconnect) {
2500 printf("QEMU waiting for connection on: %s\n",
2501 chr->filename);
2502 tcp_chr_accept(chr);
2503 socket_set_nonblock(s->listen_fd);
2504 }
2505 return chr;
2506
2507 fail:
2508 if (fd >= 0)
2509 closesocket(fd);
2510 g_free(s);
2511 g_free(chr);
2512 return NULL;
2513 }
2514
2515 /***********************************************************/
2516 /* Memory chardev */
2517 typedef struct {
2518 size_t outbuf_size;
2519 size_t outbuf_capacity;
2520 uint8_t *outbuf;
2521 } MemoryDriver;
2522
2523 static int mem_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2524 {
2525 MemoryDriver *d = chr->opaque;
2526
2527 /* TODO: the QString implementation has the same code, we should
2528 * introduce a generic way to do this in cutils.c */
2529 if (d->outbuf_capacity < d->outbuf_size + len) {
2530 /* grow outbuf */
2531 d->outbuf_capacity += len;
2532 d->outbuf_capacity *= 2;
2533 d->outbuf = g_realloc(d->outbuf, d->outbuf_capacity);
2534 }
2535
2536 memcpy(d->outbuf + d->outbuf_size, buf, len);
2537 d->outbuf_size += len;
2538
2539 return len;
2540 }
2541
2542 void qemu_chr_init_mem(CharDriverState *chr)
2543 {
2544 MemoryDriver *d;
2545
2546 d = g_malloc(sizeof(*d));
2547 d->outbuf_size = 0;
2548 d->outbuf_capacity = 4096;
2549 d->outbuf = g_malloc0(d->outbuf_capacity);
2550
2551 memset(chr, 0, sizeof(*chr));
2552 chr->opaque = d;
2553 chr->chr_write = mem_chr_write;
2554 }
2555
2556 QString *qemu_chr_mem_to_qs(CharDriverState *chr)
2557 {
2558 MemoryDriver *d = chr->opaque;
2559 return qstring_from_substr((char *) d->outbuf, 0, d->outbuf_size - 1);
2560 }
2561
2562 /* NOTE: this driver can not be closed with qemu_chr_delete()! */
2563 void qemu_chr_close_mem(CharDriverState *chr)
2564 {
2565 MemoryDriver *d = chr->opaque;
2566
2567 g_free(d->outbuf);
2568 g_free(chr->opaque);
2569 chr->opaque = NULL;
2570 chr->chr_write = NULL;
2571 }
2572
2573 size_t qemu_chr_mem_osize(const CharDriverState *chr)
2574 {
2575 const MemoryDriver *d = chr->opaque;
2576 return d->outbuf_size;
2577 }
2578
2579 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
2580 {
2581 char host[65], port[33], width[8], height[8];
2582 int pos;
2583 const char *p;
2584 QemuOpts *opts;
2585
2586 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1);
2587 if (NULL == opts)
2588 return NULL;
2589
2590 if (strstart(filename, "mon:", &p)) {
2591 filename = p;
2592 qemu_opt_set(opts, "mux", "on");
2593 }
2594
2595 if (strcmp(filename, "null") == 0 ||
2596 strcmp(filename, "pty") == 0 ||
2597 strcmp(filename, "msmouse") == 0 ||
2598 strcmp(filename, "braille") == 0 ||
2599 strcmp(filename, "stdio") == 0) {
2600 qemu_opt_set(opts, "backend", filename);
2601 return opts;
2602 }
2603 if (strstart(filename, "vc", &p)) {
2604 qemu_opt_set(opts, "backend", "vc");
2605 if (*p == ':') {
2606 if (sscanf(p+1, "%8[0-9]x%8[0-9]", width, height) == 2) {
2607 /* pixels */
2608 qemu_opt_set(opts, "width", width);
2609 qemu_opt_set(opts, "height", height);
2610 } else if (sscanf(p+1, "%8[0-9]Cx%8[0-9]C", width, height) == 2) {
2611 /* chars */
2612 qemu_opt_set(opts, "cols", width);
2613 qemu_opt_set(opts, "rows", height);
2614 } else {
2615 goto fail;
2616 }
2617 }
2618 return opts;
2619 }
2620 if (strcmp(filename, "con:") == 0) {
2621 qemu_opt_set(opts, "backend", "console");
2622 return opts;
2623 }
2624 if (strstart(filename, "COM", NULL)) {
2625 qemu_opt_set(opts, "backend", "serial");
2626 qemu_opt_set(opts, "path", filename);
2627 return opts;
2628 }
2629 if (strstart(filename, "file:", &p)) {
2630 qemu_opt_set(opts, "backend", "file");
2631 qemu_opt_set(opts, "path", p);
2632 return opts;
2633 }
2634 if (strstart(filename, "pipe:", &p)) {
2635 qemu_opt_set(opts, "backend", "pipe");
2636 qemu_opt_set(opts, "path", p);
2637 return opts;
2638 }
2639 if (strstart(filename, "tcp:", &p) ||
2640 strstart(filename, "telnet:", &p)) {
2641 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2642 host[0] = 0;
2643 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
2644 goto fail;
2645 }
2646 qemu_opt_set(opts, "backend", "socket");
2647 qemu_opt_set(opts, "host", host);
2648 qemu_opt_set(opts, "port", port);
2649 if (p[pos] == ',') {
2650 if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0)
2651 goto fail;
2652 }
2653 if (strstart(filename, "telnet:", &p))
2654 qemu_opt_set(opts, "telnet", "on");
2655 return opts;
2656 }
2657 if (strstart(filename, "udp:", &p)) {
2658 qemu_opt_set(opts, "backend", "udp");
2659 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
2660 host[0] = 0;
2661 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
2662 goto fail;
2663 }
2664 }
2665 qemu_opt_set(opts, "host", host);
2666 qemu_opt_set(opts, "port", port);
2667 if (p[pos] == '@') {
2668 p += pos + 1;
2669 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2670 host[0] = 0;
2671 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
2672 goto fail;
2673 }
2674 }
2675 qemu_opt_set(opts, "localaddr", host);
2676 qemu_opt_set(opts, "localport", port);
2677 }
2678 return opts;
2679 }
2680 if (strstart(filename, "unix:", &p)) {
2681 qemu_opt_set(opts, "backend", "socket");
2682 if (qemu_opts_do_parse(opts, p, "path") != 0)
2683 goto fail;
2684 return opts;
2685 }
2686 if (strstart(filename, "/dev/parport", NULL) ||
2687 strstart(filename, "/dev/ppi", NULL)) {
2688 qemu_opt_set(opts, "backend", "parport");
2689 qemu_opt_set(opts, "path", filename);
2690 return opts;
2691 }
2692 if (strstart(filename, "/dev/", NULL)) {
2693 qemu_opt_set(opts, "backend", "tty");
2694 qemu_opt_set(opts, "path", filename);
2695 return opts;
2696 }
2697
2698 fail:
2699 qemu_opts_del(opts);
2700 return NULL;
2701 }
2702
2703 static const struct {
2704 const char *name;
2705 CharDriverState *(*open)(QemuOpts *opts);
2706 } backend_table[] = {
2707 { .name = "null", .open = qemu_chr_open_null },
2708 { .name = "socket", .open = qemu_chr_open_socket },
2709 { .name = "udp", .open = qemu_chr_open_udp },
2710 { .name = "msmouse", .open = qemu_chr_open_msmouse },
2711 { .name = "vc", .open = text_console_init },
2712 #ifdef _WIN32
2713 { .name = "file", .open = qemu_chr_open_win_file_out },
2714 { .name = "pipe", .open = qemu_chr_open_win_pipe },
2715 { .name = "console", .open = qemu_chr_open_win_con },
2716 { .name = "serial", .open = qemu_chr_open_win },
2717 { .name = "stdio", .open = qemu_chr_open_win_stdio },
2718 #else
2719 { .name = "file", .open = qemu_chr_open_file_out },
2720 { .name = "pipe", .open = qemu_chr_open_pipe },
2721 { .name = "pty", .open = qemu_chr_open_pty },
2722 { .name = "stdio", .open = qemu_chr_open_stdio },
2723 #endif
2724 #ifdef CONFIG_BRLAPI
2725 { .name = "braille", .open = chr_baum_init },
2726 #endif
2727 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2728 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
2729 || defined(__FreeBSD_kernel__)
2730 { .name = "tty", .open = qemu_chr_open_tty },
2731 #endif
2732 #if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__) \
2733 || defined(__FreeBSD_kernel__)
2734 { .name = "parport", .open = qemu_chr_open_pp },
2735 #endif
2736 #ifdef CONFIG_SPICE
2737 { .name = "spicevmc", .open = qemu_chr_open_spice },
2738 #endif
2739 };
2740
2741 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
2742 void (*init)(struct CharDriverState *s))
2743 {
2744 CharDriverState *chr;
2745 int i;
2746
2747 if (qemu_opts_id(opts) == NULL) {
2748 fprintf(stderr, "chardev: no id specified\n");
2749 return NULL;
2750 }
2751
2752 if (qemu_opt_get(opts, "backend") == NULL) {
2753 fprintf(stderr, "chardev: \"%s\" missing backend\n",
2754 qemu_opts_id(opts));
2755 return NULL;
2756 }
2757 for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
2758 if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
2759 break;
2760 }
2761 if (i == ARRAY_SIZE(backend_table)) {
2762 fprintf(stderr, "chardev: backend \"%s\" not found\n",
2763 qemu_opt_get(opts, "backend"));
2764 return NULL;
2765 }
2766
2767 chr = backend_table[i].open(opts);
2768 if (!chr) {
2769 fprintf(stderr, "chardev: opening backend \"%s\" failed\n",
2770 qemu_opt_get(opts, "backend"));
2771 return NULL;
2772 }
2773
2774 if (!chr->filename)
2775 chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
2776 chr->init = init;
2777 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2778
2779 if (qemu_opt_get_bool(opts, "mux", 0)) {
2780 CharDriverState *base = chr;
2781 int len = strlen(qemu_opts_id(opts)) + 6;
2782 base->label = g_malloc(len);
2783 snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
2784 chr = qemu_chr_open_mux(base);
2785 chr->filename = base->filename;
2786 chr->avail_connections = MAX_MUX;
2787 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2788 } else {
2789 chr->avail_connections = 1;
2790 }
2791 chr->label = g_strdup(qemu_opts_id(opts));
2792 return chr;
2793 }
2794
2795 CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
2796 {
2797 const char *p;
2798 CharDriverState *chr;
2799 QemuOpts *opts;
2800
2801 if (strstart(filename, "chardev:", &p)) {
2802 return qemu_chr_find(p);
2803 }
2804
2805 opts = qemu_chr_parse_compat(label, filename);
2806 if (!opts)
2807 return NULL;
2808
2809 chr = qemu_chr_new_from_opts(opts, init);
2810 if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
2811 monitor_init(chr, MONITOR_USE_READLINE);
2812 }
2813 qemu_opts_del(opts);
2814 return chr;
2815 }
2816
2817 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo)
2818 {
2819 if (chr->chr_set_echo) {
2820 chr->chr_set_echo(chr, echo);
2821 }
2822 }
2823
2824 void qemu_chr_fe_open(struct CharDriverState *chr)
2825 {
2826 if (chr->chr_guest_open) {
2827 chr->chr_guest_open(chr);
2828 }
2829 }
2830
2831 void qemu_chr_fe_close(struct CharDriverState *chr)
2832 {
2833 if (chr->chr_guest_close) {
2834 chr->chr_guest_close(chr);
2835 }
2836 }
2837
2838 void qemu_chr_delete(CharDriverState *chr)
2839 {
2840 QTAILQ_REMOVE(&chardevs, chr, next);
2841 if (chr->chr_close)
2842 chr->chr_close(chr);
2843 g_free(chr->filename);
2844 g_free(chr->label);
2845 g_free(chr);
2846 }
2847
2848 ChardevInfoList *qmp_query_chardev(Error **errp)
2849 {
2850 ChardevInfoList *chr_list = NULL;
2851 CharDriverState *chr;
2852
2853 QTAILQ_FOREACH(chr, &chardevs, next) {
2854 ChardevInfoList *info = g_malloc0(sizeof(*info));
2855 info->value = g_malloc0(sizeof(*info->value));
2856 info->value->label = g_strdup(chr->label);
2857 info->value->filename = g_strdup(chr->filename);
2858
2859 info->next = chr_list;
2860 chr_list = info;
2861 }
2862
2863 return chr_list;
2864 }
2865
2866 CharDriverState *qemu_chr_find(const char *name)
2867 {
2868 CharDriverState *chr;
2869
2870 QTAILQ_FOREACH(chr, &chardevs, next) {
2871 if (strcmp(chr->label, name) != 0)
2872 continue;
2873 return chr;
2874 }
2875 return NULL;
2876 }
2877
2878 /* Get a character (serial) device interface. */
2879 CharDriverState *qemu_char_get_next_serial(void)
2880 {
2881 static int next_serial;
2882
2883 /* FIXME: This function needs to go away: use chardev properties! */
2884 return serial_hds[next_serial++];
2885 }
2886
Qemu copy for testing