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