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