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