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