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