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