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