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