]> git.proxmox.com Git - qemu.git/blob - qemu-char.c
projects / qemu.git / blob
? search:


5a81e8f5f357b130f3232c7b32226017adf47fdc
[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 "net.h"
26 #include "monitor.h"
27 #include "console.h"
28 #include "sysemu.h"
29 #include "qemu-timer.h"
30 #include "qemu-char.h"
31 #include "block.h"
32 #include "hw/usb.h"
33 #include "hw/baum.h"
34 #include "hw/msmouse.h"
35
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <signal.h>
39 #include <time.h>
40 #include <errno.h>
41 #include <sys/time.h>
42 #include <zlib.h>
43
44 #ifndef _WIN32
45 #include <sys/times.h>
46 #include <sys/wait.h>
47 #include <termios.h>
48 #include <sys/mman.h>
49 #include <sys/ioctl.h>
50 #include <sys/resource.h>
51 #include <sys/socket.h>
52 #include <netinet/in.h>
53 #include <net/if.h>
54 #include <arpa/inet.h>
55 #include <dirent.h>
56 #include <netdb.h>
57 #include <sys/select.h>
58 #ifdef CONFIG_BSD
59 #include <sys/stat.h>
60 #ifdef __FreeBSD__
61 #include <libutil.h>
62 #include <dev/ppbus/ppi.h>
63 #include <dev/ppbus/ppbconf.h>
64 #elif defined(__DragonFly__)
65 #include <libutil.h>
66 #include <dev/misc/ppi/ppi.h>
67 #include <bus/ppbus/ppbconf.h>
68 #else
69 #include <util.h>
70 #endif
71 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72 #include <freebsd/stdlib.h>
73 #else
74 #ifdef __linux__
75 #include <pty.h>
76
77 #include <linux/ppdev.h>
78 #include <linux/parport.h>
79 #endif
80 #ifdef __sun__
81 #include <sys/stat.h>
82 #include <sys/ethernet.h>
83 #include <sys/sockio.h>
84 #include <netinet/arp.h>
85 #include <netinet/in.h>
86 #include <netinet/in_systm.h>
87 #include <netinet/ip.h>
88 #include <netinet/ip_icmp.h> // must come after ip.h
89 #include <netinet/udp.h>
90 #include <netinet/tcp.h>
91 #include <net/if.h>
92 #include <syslog.h>
93 #include <stropts.h>
94 #endif
95 #endif
96 #endif
97
98 #include "qemu_socket.h"
99
100 #define READ_BUF_LEN 4096
101
102 /***********************************************************/
103 /* character device */
104
105 static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
106 QTAILQ_HEAD_INITIALIZER(chardevs);
107
108 static void qemu_chr_event(CharDriverState *s, int event)
109 {
110 if (!s->chr_event)
111 return;
112 s->chr_event(s->handler_opaque, event);
113 }
114
115 static void qemu_chr_generic_open_bh(void *opaque)
116 {
117 CharDriverState *s = opaque;
118 qemu_chr_event(s, CHR_EVENT_OPENED);
119 qemu_bh_delete(s->bh);
120 s->bh = NULL;
121 }
122
123 void qemu_chr_generic_open(CharDriverState *s)
124 {
125 if (s->bh == NULL) {
126 s->bh = qemu_bh_new(qemu_chr_generic_open_bh, s);
127 qemu_bh_schedule(s->bh);
128 }
129 }
130
131 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
132 {
133 return s->chr_write(s, buf, len);
134 }
135
136 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
137 {
138 if (!s->chr_ioctl)
139 return -ENOTSUP;
140 return s->chr_ioctl(s, cmd, arg);
141 }
142
143 int qemu_chr_can_read(CharDriverState *s)
144 {
145 if (!s->chr_can_read)
146 return 0;
147 return s->chr_can_read(s->handler_opaque);
148 }
149
150 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
151 {
152 s->chr_read(s->handler_opaque, buf, len);
153 }
154
155 int qemu_chr_get_msgfd(CharDriverState *s)
156 {
157 return s->get_msgfd ? s->get_msgfd(s) : -1;
158 }
159
160 void qemu_chr_accept_input(CharDriverState *s)
161 {
162 if (s->chr_accept_input)
163 s->chr_accept_input(s);
164 }
165
166 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
167 {
168 char buf[READ_BUF_LEN];
169 va_list ap;
170 va_start(ap, fmt);
171 vsnprintf(buf, sizeof(buf), fmt, ap);
172 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
173 va_end(ap);
174 }
175
176 void qemu_chr_send_event(CharDriverState *s, int event)
177 {
178 if (s->chr_send_event)
179 s->chr_send_event(s, event);
180 }
181
182 void qemu_chr_add_handlers(CharDriverState *s,
183 IOCanRWHandler *fd_can_read,
184 IOReadHandler *fd_read,
185 IOEventHandler *fd_event,
186 void *opaque)
187 {
188 s->chr_can_read = fd_can_read;
189 s->chr_read = fd_read;
190 s->chr_event = fd_event;
191 s->handler_opaque = opaque;
192 if (s->chr_update_read_handler)
193 s->chr_update_read_handler(s);
194 }
195
196 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
197 {
198 return len;
199 }
200
201 static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
202 {
203 CharDriverState *chr;
204
205 chr = qemu_mallocz(sizeof(CharDriverState));
206 chr->chr_write = null_chr_write;
207 return chr;
208 }
209
210 /* MUX driver for serial I/O splitting */
211 #define MAX_MUX 4
212 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
213 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
214 typedef struct {
215 IOCanRWHandler *chr_can_read[MAX_MUX];
216 IOReadHandler *chr_read[MAX_MUX];
217 IOEventHandler *chr_event[MAX_MUX];
218 void *ext_opaque[MAX_MUX];
219 CharDriverState *drv;
220 int focus;
221 int mux_cnt;
222 int term_got_escape;
223 int max_size;
224 /* Intermediate input buffer allows to catch escape sequences even if the
225 currently active device is not accepting any input - but only until it
226 is full as well. */
227 unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
228 int prod[MAX_MUX];
229 int cons[MAX_MUX];
230 int timestamps;
231 int linestart;
232 int64_t timestamps_start;
233 } MuxDriver;
234
235
236 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
237 {
238 MuxDriver *d = chr->opaque;
239 int ret;
240 if (!d->timestamps) {
241 ret = d->drv->chr_write(d->drv, buf, len);
242 } else {
243 int i;
244
245 ret = 0;
246 for (i = 0; i < len; i++) {
247 if (d->linestart) {
248 char buf1[64];
249 int64_t ti;
250 int secs;
251
252 ti = qemu_get_clock(rt_clock);
253 if (d->timestamps_start == -1)
254 d->timestamps_start = ti;
255 ti -= d->timestamps_start;
256 secs = ti / 1000;
257 snprintf(buf1, sizeof(buf1),
258 "[%02d:%02d:%02d.%03d] ",
259 secs / 3600,
260 (secs / 60) % 60,
261 secs % 60,
262 (int)(ti % 1000));
263 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
264 d->linestart = 0;
265 }
266 ret += d->drv->chr_write(d->drv, buf+i, 1);
267 if (buf[i] == '\n') {
268 d->linestart = 1;
269 }
270 }
271 }
272 return ret;
273 }
274
275 static const char * const mux_help[] = {
276 "% h print this help\n\r",
277 "% x exit emulator\n\r",
278 "% s save disk data back to file (if -snapshot)\n\r",
279 "% t toggle console timestamps\n\r"
280 "% b send break (magic sysrq)\n\r",
281 "% c switch between console and monitor\n\r",
282 "% % sends %\n\r",
283 NULL
284 };
285
286 int term_escape_char = 0x01; /* ctrl-a is used for escape */
287 static void mux_print_help(CharDriverState *chr)
288 {
289 int i, j;
290 char ebuf[15] = "Escape-Char";
291 char cbuf[50] = "\n\r";
292
293 if (term_escape_char > 0 && term_escape_char < 26) {
294 snprintf(cbuf, sizeof(cbuf), "\n\r");
295 snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
296 } else {
297 snprintf(cbuf, sizeof(cbuf),
298 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
299 term_escape_char);
300 }
301 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
302 for (i = 0; mux_help[i] != NULL; i++) {
303 for (j=0; mux_help[i][j] != '\0'; j++) {
304 if (mux_help[i][j] == '%')
305 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
306 else
307 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
308 }
309 }
310 }
311
312 static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
313 {
314 if (d->chr_event[mux_nr])
315 d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
316 }
317
318 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
319 {
320 if (d->term_got_escape) {
321 d->term_got_escape = 0;
322 if (ch == term_escape_char)
323 goto send_char;
324 switch(ch) {
325 case '?':
326 case 'h':
327 mux_print_help(chr);
328 break;
329 case 'x':
330 {
331 const char *term = "QEMU: Terminated\n\r";
332 chr->chr_write(chr,(uint8_t *)term,strlen(term));
333 exit(0);
334 break;
335 }
336 case 's':
337 {
338 DriveInfo *dinfo;
339 QTAILQ_FOREACH(dinfo, &drives, next) {
340 bdrv_commit(dinfo->bdrv);
341 }
342 }
343 break;
344 case 'b':
345 qemu_chr_event(chr, CHR_EVENT_BREAK);
346 break;
347 case 'c':
348 /* Switch to the next registered device */
349 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
350 d->focus++;
351 if (d->focus >= d->mux_cnt)
352 d->focus = 0;
353 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
354 break;
355 case 't':
356 d->timestamps = !d->timestamps;
357 d->timestamps_start = -1;
358 d->linestart = 0;
359 break;
360 }
361 } else if (ch == term_escape_char) {
362 d->term_got_escape = 1;
363 } else {
364 send_char:
365 return 1;
366 }
367 return 0;
368 }
369
370 static void mux_chr_accept_input(CharDriverState *chr)
371 {
372 MuxDriver *d = chr->opaque;
373 int m = d->focus;
374
375 while (d->prod[m] != d->cons[m] &&
376 d->chr_can_read[m] &&
377 d->chr_can_read[m](d->ext_opaque[m])) {
378 d->chr_read[m](d->ext_opaque[m],
379 &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
380 }
381 }
382
383 static int mux_chr_can_read(void *opaque)
384 {
385 CharDriverState *chr = opaque;
386 MuxDriver *d = chr->opaque;
387 int m = d->focus;
388
389 if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
390 return 1;
391 if (d->chr_can_read[m])
392 return d->chr_can_read[m](d->ext_opaque[m]);
393 return 0;
394 }
395
396 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
397 {
398 CharDriverState *chr = opaque;
399 MuxDriver *d = chr->opaque;
400 int m = d->focus;
401 int i;
402
403 mux_chr_accept_input (opaque);
404
405 for(i = 0; i < size; i++)
406 if (mux_proc_byte(chr, d, buf[i])) {
407 if (d->prod[m] == d->cons[m] &&
408 d->chr_can_read[m] &&
409 d->chr_can_read[m](d->ext_opaque[m]))
410 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
411 else
412 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
413 }
414 }
415
416 static void mux_chr_event(void *opaque, int event)
417 {
418 CharDriverState *chr = opaque;
419 MuxDriver *d = chr->opaque;
420 int i;
421
422 /* Send the event to all registered listeners */
423 for (i = 0; i < d->mux_cnt; i++)
424 mux_chr_send_event(d, i, event);
425 }
426
427 static void mux_chr_update_read_handler(CharDriverState *chr)
428 {
429 MuxDriver *d = chr->opaque;
430
431 if (d->mux_cnt >= MAX_MUX) {
432 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
433 return;
434 }
435 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
436 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
437 d->chr_read[d->mux_cnt] = chr->chr_read;
438 d->chr_event[d->mux_cnt] = chr->chr_event;
439 /* Fix up the real driver with mux routines */
440 if (d->mux_cnt == 0) {
441 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
442 mux_chr_event, chr);
443 }
444 if (d->focus != -1) {
445 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
446 }
447 d->focus = d->mux_cnt;
448 d->mux_cnt++;
449 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
450 }
451
452 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
453 {
454 CharDriverState *chr;
455 MuxDriver *d;
456
457 chr = qemu_mallocz(sizeof(CharDriverState));
458 d = qemu_mallocz(sizeof(MuxDriver));
459
460 chr->opaque = d;
461 d->drv = drv;
462 d->focus = -1;
463 chr->chr_write = mux_chr_write;
464 chr->chr_update_read_handler = mux_chr_update_read_handler;
465 chr->chr_accept_input = mux_chr_accept_input;
466 return chr;
467 }
468
469
470 #ifdef _WIN32
471 int send_all(int fd, const void *buf, int len1)
472 {
473 int ret, len;
474
475 len = len1;
476 while (len > 0) {
477 ret = send(fd, buf, len, 0);
478 if (ret < 0) {
479 errno = WSAGetLastError();
480 if (errno != WSAEWOULDBLOCK) {
481 return -1;
482 }
483 } else if (ret == 0) {
484 break;
485 } else {
486 buf += ret;
487 len -= ret;
488 }
489 }
490 return len1 - len;
491 }
492
493 #else
494
495 static int unix_write(int fd, const uint8_t *buf, int len1)
496 {
497 int ret, len;
498
499 len = len1;
500 while (len > 0) {
501 ret = write(fd, buf, len);
502 if (ret < 0) {
503 if (errno != EINTR && errno != EAGAIN)
504 return -1;
505 } else if (ret == 0) {
506 break;
507 } else {
508 buf += ret;
509 len -= ret;
510 }
511 }
512 return len1 - len;
513 }
514
515 int send_all(int fd, const void *buf, int len1)
516 {
517 return unix_write(fd, buf, len1);
518 }
519 #endif /* !_WIN32 */
520
521 #ifndef _WIN32
522
523 typedef struct {
524 int fd_in, fd_out;
525 int max_size;
526 } FDCharDriver;
527
528 #define STDIO_MAX_CLIENTS 1
529 static int stdio_nb_clients = 0;
530
531 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
532 {
533 FDCharDriver *s = chr->opaque;
534 return send_all(s->fd_out, buf, len);
535 }
536
537 static int fd_chr_read_poll(void *opaque)
538 {
539 CharDriverState *chr = opaque;
540 FDCharDriver *s = chr->opaque;
541
542 s->max_size = qemu_chr_can_read(chr);
543 return s->max_size;
544 }
545
546 static void fd_chr_read(void *opaque)
547 {
548 CharDriverState *chr = opaque;
549 FDCharDriver *s = chr->opaque;
550 int size, len;
551 uint8_t buf[READ_BUF_LEN];
552
553 len = sizeof(buf);
554 if (len > s->max_size)
555 len = s->max_size;
556 if (len == 0)
557 return;
558 size = read(s->fd_in, buf, len);
559 if (size == 0) {
560 /* FD has been closed. Remove it from the active list. */
561 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
562 qemu_chr_event(chr, CHR_EVENT_CLOSED);
563 return;
564 }
565 if (size > 0) {
566 qemu_chr_read(chr, buf, size);
567 }
568 }
569
570 static void fd_chr_update_read_handler(CharDriverState *chr)
571 {
572 FDCharDriver *s = chr->opaque;
573
574 if (s->fd_in >= 0) {
575 if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
576 } else {
577 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
578 fd_chr_read, NULL, chr);
579 }
580 }
581 }
582
583 static void fd_chr_close(struct CharDriverState *chr)
584 {
585 FDCharDriver *s = chr->opaque;
586
587 if (s->fd_in >= 0) {
588 if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
589 } else {
590 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
591 }
592 }
593
594 qemu_free(s);
595 qemu_chr_event(chr, CHR_EVENT_CLOSED);
596 }
597
598 /* open a character device to a unix fd */
599 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
600 {
601 CharDriverState *chr;
602 FDCharDriver *s;
603
604 chr = qemu_mallocz(sizeof(CharDriverState));
605 s = qemu_mallocz(sizeof(FDCharDriver));
606 s->fd_in = fd_in;
607 s->fd_out = fd_out;
608 chr->opaque = s;
609 chr->chr_write = fd_chr_write;
610 chr->chr_update_read_handler = fd_chr_update_read_handler;
611 chr->chr_close = fd_chr_close;
612
613 qemu_chr_generic_open(chr);
614
615 return chr;
616 }
617
618 static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
619 {
620 int fd_out;
621
622 TFR(fd_out = open(qemu_opt_get(opts, "path"),
623 O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
624 if (fd_out < 0)
625 return NULL;
626 return qemu_chr_open_fd(-1, fd_out);
627 }
628
629 static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
630 {
631 int fd_in, fd_out;
632 char filename_in[256], filename_out[256];
633 const char *filename = qemu_opt_get(opts, "path");
634
635 if (filename == NULL) {
636 fprintf(stderr, "chardev: pipe: no filename given\n");
637 return NULL;
638 }
639
640 snprintf(filename_in, 256, "%s.in", filename);
641 snprintf(filename_out, 256, "%s.out", filename);
642 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
643 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
644 if (fd_in < 0 || fd_out < 0) {
645 if (fd_in >= 0)
646 close(fd_in);
647 if (fd_out >= 0)
648 close(fd_out);
649 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
650 if (fd_in < 0)
651 return NULL;
652 }
653 return qemu_chr_open_fd(fd_in, fd_out);
654 }
655
656
657 /* for STDIO, we handle the case where several clients use it
658 (nographic mode) */
659
660 #define TERM_FIFO_MAX_SIZE 1
661
662 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
663 static int term_fifo_size;
664
665 static int stdio_read_poll(void *opaque)
666 {
667 CharDriverState *chr = opaque;
668
669 /* try to flush the queue if needed */
670 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
671 qemu_chr_read(chr, term_fifo, 1);
672 term_fifo_size = 0;
673 }
674 /* see if we can absorb more chars */
675 if (term_fifo_size == 0)
676 return 1;
677 else
678 return 0;
679 }
680
681 static void stdio_read(void *opaque)
682 {
683 int size;
684 uint8_t buf[1];
685 CharDriverState *chr = opaque;
686
687 size = read(0, buf, 1);
688 if (size == 0) {
689 /* stdin has been closed. Remove it from the active list. */
690 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
691 qemu_chr_event(chr, CHR_EVENT_CLOSED);
692 return;
693 }
694 if (size > 0) {
695 if (qemu_chr_can_read(chr) > 0) {
696 qemu_chr_read(chr, buf, 1);
697 } else if (term_fifo_size == 0) {
698 term_fifo[term_fifo_size++] = buf[0];
699 }
700 }
701 }
702
703 /* init terminal so that we can grab keys */
704 static struct termios oldtty;
705 static int old_fd0_flags;
706 static int term_atexit_done;
707
708 static void term_exit(void)
709 {
710 tcsetattr (0, TCSANOW, &oldtty);
711 fcntl(0, F_SETFL, old_fd0_flags);
712 }
713
714 static void term_init(QemuOpts *opts)
715 {
716 struct termios tty;
717
718 tcgetattr (0, &tty);
719 oldtty = tty;
720 old_fd0_flags = fcntl(0, F_GETFL);
721
722 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
723 |INLCR|IGNCR|ICRNL|IXON);
724 tty.c_oflag |= OPOST;
725 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
726 /* if graphical mode, we allow Ctrl-C handling */
727 if (!qemu_opt_get_bool(opts, "signal", display_type != DT_NOGRAPHIC))
728 tty.c_lflag &= ~ISIG;
729 tty.c_cflag &= ~(CSIZE|PARENB);
730 tty.c_cflag |= CS8;
731 tty.c_cc[VMIN] = 1;
732 tty.c_cc[VTIME] = 0;
733
734 tcsetattr (0, TCSANOW, &tty);
735
736 if (!term_atexit_done++)
737 atexit(term_exit);
738
739 fcntl(0, F_SETFL, O_NONBLOCK);
740 }
741
742 static void qemu_chr_close_stdio(struct CharDriverState *chr)
743 {
744 term_exit();
745 stdio_nb_clients--;
746 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
747 fd_chr_close(chr);
748 }
749
750 static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
751 {
752 CharDriverState *chr;
753
754 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
755 return NULL;
756 chr = qemu_chr_open_fd(0, 1);
757 chr->chr_close = qemu_chr_close_stdio;
758 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
759 stdio_nb_clients++;
760 term_init(opts);
761
762 return chr;
763 }
764
765 #ifdef __sun__
766 /* Once Solaris has openpty(), this is going to be removed. */
767 static int openpty(int *amaster, int *aslave, char *name,
768 struct termios *termp, struct winsize *winp)
769 {
770 const char *slave;
771 int mfd = -1, sfd = -1;
772
773 *amaster = *aslave = -1;
774
775 mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
776 if (mfd < 0)
777 goto err;
778
779 if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
780 goto err;
781
782 if ((slave = ptsname(mfd)) == NULL)
783 goto err;
784
785 if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
786 goto err;
787
788 if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
789 (termp != NULL && tcgetattr(sfd, termp) < 0))
790 goto err;
791
792 if (amaster)
793 *amaster = mfd;
794 if (aslave)
795 *aslave = sfd;
796 if (winp)
797 ioctl(sfd, TIOCSWINSZ, winp);
798
799 return 0;
800
801 err:
802 if (sfd != -1)
803 close(sfd);
804 close(mfd);
805 return -1;
806 }
807
808 static void cfmakeraw (struct termios *termios_p)
809 {
810 termios_p->c_iflag &=
811 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
812 termios_p->c_oflag &= ~OPOST;
813 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
814 termios_p->c_cflag &= ~(CSIZE|PARENB);
815 termios_p->c_cflag |= CS8;
816
817 termios_p->c_cc[VMIN] = 0;
818 termios_p->c_cc[VTIME] = 0;
819 }
820 #endif
821
822 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
823 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
824
825 typedef struct {
826 int fd;
827 int connected;
828 int polling;
829 int read_bytes;
830 QEMUTimer *timer;
831 } PtyCharDriver;
832
833 static void pty_chr_update_read_handler(CharDriverState *chr);
834 static void pty_chr_state(CharDriverState *chr, int connected);
835
836 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
837 {
838 PtyCharDriver *s = chr->opaque;
839
840 if (!s->connected) {
841 /* guest sends data, check for (re-)connect */
842 pty_chr_update_read_handler(chr);
843 return 0;
844 }
845 return send_all(s->fd, buf, len);
846 }
847
848 static int pty_chr_read_poll(void *opaque)
849 {
850 CharDriverState *chr = opaque;
851 PtyCharDriver *s = chr->opaque;
852
853 s->read_bytes = qemu_chr_can_read(chr);
854 return s->read_bytes;
855 }
856
857 static void pty_chr_read(void *opaque)
858 {
859 CharDriverState *chr = opaque;
860 PtyCharDriver *s = chr->opaque;
861 int size, len;
862 uint8_t buf[READ_BUF_LEN];
863
864 len = sizeof(buf);
865 if (len > s->read_bytes)
866 len = s->read_bytes;
867 if (len == 0)
868 return;
869 size = read(s->fd, buf, len);
870 if ((size == -1 && errno == EIO) ||
871 (size == 0)) {
872 pty_chr_state(chr, 0);
873 return;
874 }
875 if (size > 0) {
876 pty_chr_state(chr, 1);
877 qemu_chr_read(chr, buf, size);
878 }
879 }
880
881 static void pty_chr_update_read_handler(CharDriverState *chr)
882 {
883 PtyCharDriver *s = chr->opaque;
884
885 qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
886 pty_chr_read, NULL, chr);
887 s->polling = 1;
888 /*
889 * Short timeout here: just need wait long enougth that qemu makes
890 * it through the poll loop once. When reconnected we want a
891 * short timeout so we notice it almost instantly. Otherwise
892 * read() gives us -EIO instantly, making pty_chr_state() reset the
893 * timeout to the normal (much longer) poll interval before the
894 * timer triggers.
895 */
896 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
897 }
898
899 static void pty_chr_state(CharDriverState *chr, int connected)
900 {
901 PtyCharDriver *s = chr->opaque;
902
903 if (!connected) {
904 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
905 s->connected = 0;
906 s->polling = 0;
907 /* (re-)connect poll interval for idle guests: once per second.
908 * We check more frequently in case the guests sends data to
909 * the virtual device linked to our pty. */
910 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
911 } else {
912 if (!s->connected)
913 qemu_chr_generic_open(chr);
914 s->connected = 1;
915 }
916 }
917
918 static void pty_chr_timer(void *opaque)
919 {
920 struct CharDriverState *chr = opaque;
921 PtyCharDriver *s = chr->opaque;
922
923 if (s->connected)
924 return;
925 if (s->polling) {
926 /* If we arrive here without polling being cleared due
927 * read returning -EIO, then we are (re-)connected */
928 pty_chr_state(chr, 1);
929 return;
930 }
931
932 /* Next poll ... */
933 pty_chr_update_read_handler(chr);
934 }
935
936 static void pty_chr_close(struct CharDriverState *chr)
937 {
938 PtyCharDriver *s = chr->opaque;
939
940 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
941 close(s->fd);
942 qemu_del_timer(s->timer);
943 qemu_free_timer(s->timer);
944 qemu_free(s);
945 qemu_chr_event(chr, CHR_EVENT_CLOSED);
946 }
947
948 static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
949 {
950 CharDriverState *chr;
951 PtyCharDriver *s;
952 struct termios tty;
953 int slave_fd, len;
954 #if defined(__OpenBSD__) || defined(__DragonFly__)
955 char pty_name[PATH_MAX];
956 #define q_ptsname(x) pty_name
957 #else
958 char *pty_name = NULL;
959 #define q_ptsname(x) ptsname(x)
960 #endif
961
962 chr = qemu_mallocz(sizeof(CharDriverState));
963 s = qemu_mallocz(sizeof(PtyCharDriver));
964
965 if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
966 return NULL;
967 }
968
969 /* Set raw attributes on the pty. */
970 tcgetattr(slave_fd, &tty);
971 cfmakeraw(&tty);
972 tcsetattr(slave_fd, TCSAFLUSH, &tty);
973 close(slave_fd);
974
975 len = strlen(q_ptsname(s->fd)) + 5;
976 chr->filename = qemu_malloc(len);
977 snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
978 qemu_opt_set(opts, "path", q_ptsname(s->fd));
979 fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
980
981 chr->opaque = s;
982 chr->chr_write = pty_chr_write;
983 chr->chr_update_read_handler = pty_chr_update_read_handler;
984 chr->chr_close = pty_chr_close;
985
986 s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
987
988 return chr;
989 }
990
991 static void tty_serial_init(int fd, int speed,
992 int parity, int data_bits, int stop_bits)
993 {
994 struct termios tty;
995 speed_t spd;
996
997 #if 0
998 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
999 speed, parity, data_bits, stop_bits);
1000 #endif
1001 tcgetattr (fd, &tty);
1002
1003 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
1004 speed = speed * 10 / 11;
1005 do {
1006 check_speed(50);
1007 check_speed(75);
1008 check_speed(110);
1009 check_speed(134);
1010 check_speed(150);
1011 check_speed(200);
1012 check_speed(300);
1013 check_speed(600);
1014 check_speed(1200);
1015 check_speed(1800);
1016 check_speed(2400);
1017 check_speed(4800);
1018 check_speed(9600);
1019 check_speed(19200);
1020 check_speed(38400);
1021 /* Non-Posix values follow. They may be unsupported on some systems. */
1022 check_speed(57600);
1023 check_speed(115200);
1024 #ifdef B230400
1025 check_speed(230400);
1026 #endif
1027 #ifdef B460800
1028 check_speed(460800);
1029 #endif
1030 #ifdef B500000
1031 check_speed(500000);
1032 #endif
1033 #ifdef B576000
1034 check_speed(576000);
1035 #endif
1036 #ifdef B921600
1037 check_speed(921600);
1038 #endif
1039 #ifdef B1000000
1040 check_speed(1000000);
1041 #endif
1042 #ifdef B1152000
1043 check_speed(1152000);
1044 #endif
1045 #ifdef B1500000
1046 check_speed(1500000);
1047 #endif
1048 #ifdef B2000000
1049 check_speed(2000000);
1050 #endif
1051 #ifdef B2500000
1052 check_speed(2500000);
1053 #endif
1054 #ifdef B3000000
1055 check_speed(3000000);
1056 #endif
1057 #ifdef B3500000
1058 check_speed(3500000);
1059 #endif
1060 #ifdef B4000000
1061 check_speed(4000000);
1062 #endif
1063 spd = B115200;
1064 } while (0);
1065
1066 cfsetispeed(&tty, spd);
1067 cfsetospeed(&tty, spd);
1068
1069 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1070 |INLCR|IGNCR|ICRNL|IXON);
1071 tty.c_oflag |= OPOST;
1072 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1073 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1074 switch(data_bits) {
1075 default:
1076 case 8:
1077 tty.c_cflag |= CS8;
1078 break;
1079 case 7:
1080 tty.c_cflag |= CS7;
1081 break;
1082 case 6:
1083 tty.c_cflag |= CS6;
1084 break;
1085 case 5:
1086 tty.c_cflag |= CS5;
1087 break;
1088 }
1089 switch(parity) {
1090 default:
1091 case 'N':
1092 break;
1093 case 'E':
1094 tty.c_cflag |= PARENB;
1095 break;
1096 case 'O':
1097 tty.c_cflag |= PARENB | PARODD;
1098 break;
1099 }
1100 if (stop_bits == 2)
1101 tty.c_cflag |= CSTOPB;
1102
1103 tcsetattr (fd, TCSANOW, &tty);
1104 }
1105
1106 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1107 {
1108 FDCharDriver *s = chr->opaque;
1109
1110 switch(cmd) {
1111 case CHR_IOCTL_SERIAL_SET_PARAMS:
1112 {
1113 QEMUSerialSetParams *ssp = arg;
1114 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1115 ssp->data_bits, ssp->stop_bits);
1116 }
1117 break;
1118 case CHR_IOCTL_SERIAL_SET_BREAK:
1119 {
1120 int enable = *(int *)arg;
1121 if (enable)
1122 tcsendbreak(s->fd_in, 1);
1123 }
1124 break;
1125 case CHR_IOCTL_SERIAL_GET_TIOCM:
1126 {
1127 int sarg = 0;
1128 int *targ = (int *)arg;
1129 ioctl(s->fd_in, TIOCMGET, &sarg);
1130 *targ = 0;
1131 if (sarg & TIOCM_CTS)
1132 *targ |= CHR_TIOCM_CTS;
1133 if (sarg & TIOCM_CAR)
1134 *targ |= CHR_TIOCM_CAR;
1135 if (sarg & TIOCM_DSR)
1136 *targ |= CHR_TIOCM_DSR;
1137 if (sarg & TIOCM_RI)
1138 *targ |= CHR_TIOCM_RI;
1139 if (sarg & TIOCM_DTR)
1140 *targ |= CHR_TIOCM_DTR;
1141 if (sarg & TIOCM_RTS)
1142 *targ |= CHR_TIOCM_RTS;
1143 }
1144 break;
1145 case CHR_IOCTL_SERIAL_SET_TIOCM:
1146 {
1147 int sarg = *(int *)arg;
1148 int targ = 0;
1149 ioctl(s->fd_in, TIOCMGET, &targ);
1150 targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
1151 | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
1152 if (sarg & CHR_TIOCM_CTS)
1153 targ |= TIOCM_CTS;
1154 if (sarg & CHR_TIOCM_CAR)
1155 targ |= TIOCM_CAR;
1156 if (sarg & CHR_TIOCM_DSR)
1157 targ |= TIOCM_DSR;
1158 if (sarg & CHR_TIOCM_RI)
1159 targ |= TIOCM_RI;
1160 if (sarg & CHR_TIOCM_DTR)
1161 targ |= TIOCM_DTR;
1162 if (sarg & CHR_TIOCM_RTS)
1163 targ |= TIOCM_RTS;
1164 ioctl(s->fd_in, TIOCMSET, &targ);
1165 }
1166 break;
1167 default:
1168 return -ENOTSUP;
1169 }
1170 return 0;
1171 }
1172
1173 static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
1174 {
1175 const char *filename = qemu_opt_get(opts, "path");
1176 CharDriverState *chr;
1177 int fd;
1178
1179 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
1180 tty_serial_init(fd, 115200, 'N', 8, 1);
1181 chr = qemu_chr_open_fd(fd, fd);
1182 if (!chr) {
1183 close(fd);
1184 return NULL;
1185 }
1186 chr->chr_ioctl = tty_serial_ioctl;
1187 qemu_chr_generic_open(chr);
1188 return chr;
1189 }
1190 #else /* ! __linux__ && ! __sun__ */
1191 static CharDriverState *qemu_chr_open_pty(void)
1192 {
1193 return NULL;
1194 }
1195 #endif /* __linux__ || __sun__ */
1196
1197 #if defined(__linux__)
1198 typedef struct {
1199 int fd;
1200 int mode;
1201 } ParallelCharDriver;
1202
1203 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
1204 {
1205 if (s->mode != mode) {
1206 int m = mode;
1207 if (ioctl(s->fd, PPSETMODE, &m) < 0)
1208 return 0;
1209 s->mode = mode;
1210 }
1211 return 1;
1212 }
1213
1214 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1215 {
1216 ParallelCharDriver *drv = chr->opaque;
1217 int fd = drv->fd;
1218 uint8_t b;
1219
1220 switch(cmd) {
1221 case CHR_IOCTL_PP_READ_DATA:
1222 if (ioctl(fd, PPRDATA, &b) < 0)
1223 return -ENOTSUP;
1224 *(uint8_t *)arg = b;
1225 break;
1226 case CHR_IOCTL_PP_WRITE_DATA:
1227 b = *(uint8_t *)arg;
1228 if (ioctl(fd, PPWDATA, &b) < 0)
1229 return -ENOTSUP;
1230 break;
1231 case CHR_IOCTL_PP_READ_CONTROL:
1232 if (ioctl(fd, PPRCONTROL, &b) < 0)
1233 return -ENOTSUP;
1234 /* Linux gives only the lowest bits, and no way to know data
1235 direction! For better compatibility set the fixed upper
1236 bits. */
1237 *(uint8_t *)arg = b | 0xc0;
1238 break;
1239 case CHR_IOCTL_PP_WRITE_CONTROL:
1240 b = *(uint8_t *)arg;
1241 if (ioctl(fd, PPWCONTROL, &b) < 0)
1242 return -ENOTSUP;
1243 break;
1244 case CHR_IOCTL_PP_READ_STATUS:
1245 if (ioctl(fd, PPRSTATUS, &b) < 0)
1246 return -ENOTSUP;
1247 *(uint8_t *)arg = b;
1248 break;
1249 case CHR_IOCTL_PP_DATA_DIR:
1250 if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
1251 return -ENOTSUP;
1252 break;
1253 case CHR_IOCTL_PP_EPP_READ_ADDR:
1254 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1255 struct ParallelIOArg *parg = arg;
1256 int n = read(fd, parg->buffer, parg->count);
1257 if (n != parg->count) {
1258 return -EIO;
1259 }
1260 }
1261 break;
1262 case CHR_IOCTL_PP_EPP_READ:
1263 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1264 struct ParallelIOArg *parg = arg;
1265 int n = read(fd, parg->buffer, parg->count);
1266 if (n != parg->count) {
1267 return -EIO;
1268 }
1269 }
1270 break;
1271 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
1272 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1273 struct ParallelIOArg *parg = arg;
1274 int n = write(fd, parg->buffer, parg->count);
1275 if (n != parg->count) {
1276 return -EIO;
1277 }
1278 }
1279 break;
1280 case CHR_IOCTL_PP_EPP_WRITE:
1281 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1282 struct ParallelIOArg *parg = arg;
1283 int n = write(fd, parg->buffer, parg->count);
1284 if (n != parg->count) {
1285 return -EIO;
1286 }
1287 }
1288 break;
1289 default:
1290 return -ENOTSUP;
1291 }
1292 return 0;
1293 }
1294
1295 static void pp_close(CharDriverState *chr)
1296 {
1297 ParallelCharDriver *drv = chr->opaque;
1298 int fd = drv->fd;
1299
1300 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
1301 ioctl(fd, PPRELEASE);
1302 close(fd);
1303 qemu_free(drv);
1304 qemu_chr_event(chr, CHR_EVENT_CLOSED);
1305 }
1306
1307 static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1308 {
1309 const char *filename = qemu_opt_get(opts, "path");
1310 CharDriverState *chr;
1311 ParallelCharDriver *drv;
1312 int fd;
1313
1314 TFR(fd = open(filename, O_RDWR));
1315 if (fd < 0)
1316 return NULL;
1317
1318 if (ioctl(fd, PPCLAIM) < 0) {
1319 close(fd);
1320 return NULL;
1321 }
1322
1323 drv = qemu_mallocz(sizeof(ParallelCharDriver));
1324 drv->fd = fd;
1325 drv->mode = IEEE1284_MODE_COMPAT;
1326
1327 chr = qemu_mallocz(sizeof(CharDriverState));
1328 chr->chr_write = null_chr_write;
1329 chr->chr_ioctl = pp_ioctl;
1330 chr->chr_close = pp_close;
1331 chr->opaque = drv;
1332
1333 qemu_chr_generic_open(chr);
1334
1335 return chr;
1336 }
1337 #endif /* __linux__ */
1338
1339 #if defined(__FreeBSD__) || defined(__DragonFly__)
1340 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1341 {
1342 int fd = (int)chr->opaque;
1343 uint8_t b;
1344
1345 switch(cmd) {
1346 case CHR_IOCTL_PP_READ_DATA:
1347 if (ioctl(fd, PPIGDATA, &b) < 0)
1348 return -ENOTSUP;
1349 *(uint8_t *)arg = b;
1350 break;
1351 case CHR_IOCTL_PP_WRITE_DATA:
1352 b = *(uint8_t *)arg;
1353 if (ioctl(fd, PPISDATA, &b) < 0)
1354 return -ENOTSUP;
1355 break;
1356 case CHR_IOCTL_PP_READ_CONTROL:
1357 if (ioctl(fd, PPIGCTRL, &b) < 0)
1358 return -ENOTSUP;
1359 *(uint8_t *)arg = b;
1360 break;
1361 case CHR_IOCTL_PP_WRITE_CONTROL:
1362 b = *(uint8_t *)arg;
1363 if (ioctl(fd, PPISCTRL, &b) < 0)
1364 return -ENOTSUP;
1365 break;
1366 case CHR_IOCTL_PP_READ_STATUS:
1367 if (ioctl(fd, PPIGSTATUS, &b) < 0)
1368 return -ENOTSUP;
1369 *(uint8_t *)arg = b;
1370 break;
1371 default:
1372 return -ENOTSUP;
1373 }
1374 return 0;
1375 }
1376
1377 static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1378 {
1379 const char *filename = qemu_opt_get(opts, "path");
1380 CharDriverState *chr;
1381 int fd;
1382
1383 fd = open(filename, O_RDWR);
1384 if (fd < 0)
1385 return NULL;
1386
1387 chr = qemu_mallocz(sizeof(CharDriverState));
1388 chr->opaque = (void *)fd;
1389 chr->chr_write = null_chr_write;
1390 chr->chr_ioctl = pp_ioctl;
1391 return chr;
1392 }
1393 #endif
1394
1395 #else /* _WIN32 */
1396
1397 typedef struct {
1398 int max_size;
1399 HANDLE hcom, hrecv, hsend;
1400 OVERLAPPED orecv, osend;
1401 BOOL fpipe;
1402 DWORD len;
1403 } WinCharState;
1404
1405 #define NSENDBUF 2048
1406 #define NRECVBUF 2048
1407 #define MAXCONNECT 1
1408 #define NTIMEOUT 5000
1409
1410 static int win_chr_poll(void *opaque);
1411 static int win_chr_pipe_poll(void *opaque);
1412
1413 static void win_chr_close(CharDriverState *chr)
1414 {
1415 WinCharState *s = chr->opaque;
1416
1417 if (s->hsend) {
1418 CloseHandle(s->hsend);
1419 s->hsend = NULL;
1420 }
1421 if (s->hrecv) {
1422 CloseHandle(s->hrecv);
1423 s->hrecv = NULL;
1424 }
1425 if (s->hcom) {
1426 CloseHandle(s->hcom);
1427 s->hcom = NULL;
1428 }
1429 if (s->fpipe)
1430 qemu_del_polling_cb(win_chr_pipe_poll, chr);
1431 else
1432 qemu_del_polling_cb(win_chr_poll, chr);
1433
1434 qemu_chr_event(chr, CHR_EVENT_CLOSED);
1435 }
1436
1437 static int win_chr_init(CharDriverState *chr, const char *filename)
1438 {
1439 WinCharState *s = chr->opaque;
1440 COMMCONFIG comcfg;
1441 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1442 COMSTAT comstat;
1443 DWORD size;
1444 DWORD err;
1445
1446 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1447 if (!s->hsend) {
1448 fprintf(stderr, "Failed CreateEvent\n");
1449 goto fail;
1450 }
1451 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1452 if (!s->hrecv) {
1453 fprintf(stderr, "Failed CreateEvent\n");
1454 goto fail;
1455 }
1456
1457 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1458 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1459 if (s->hcom == INVALID_HANDLE_VALUE) {
1460 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1461 s->hcom = NULL;
1462 goto fail;
1463 }
1464
1465 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1466 fprintf(stderr, "Failed SetupComm\n");
1467 goto fail;
1468 }
1469
1470 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1471 size = sizeof(COMMCONFIG);
1472 GetDefaultCommConfig(filename, &comcfg, &size);
1473 comcfg.dcb.DCBlength = sizeof(DCB);
1474 CommConfigDialog(filename, NULL, &comcfg);
1475
1476 if (!SetCommState(s->hcom, &comcfg.dcb)) {
1477 fprintf(stderr, "Failed SetCommState\n");
1478 goto fail;
1479 }
1480
1481 if (!SetCommMask(s->hcom, EV_ERR)) {
1482 fprintf(stderr, "Failed SetCommMask\n");
1483 goto fail;
1484 }
1485
1486 cto.ReadIntervalTimeout = MAXDWORD;
1487 if (!SetCommTimeouts(s->hcom, &cto)) {
1488 fprintf(stderr, "Failed SetCommTimeouts\n");
1489 goto fail;
1490 }
1491
1492 if (!ClearCommError(s->hcom, &err, &comstat)) {
1493 fprintf(stderr, "Failed ClearCommError\n");
1494 goto fail;
1495 }
1496 qemu_add_polling_cb(win_chr_poll, chr);
1497 return 0;
1498
1499 fail:
1500 win_chr_close(chr);
1501 return -1;
1502 }
1503
1504 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1505 {
1506 WinCharState *s = chr->opaque;
1507 DWORD len, ret, size, err;
1508
1509 len = len1;
1510 ZeroMemory(&s->osend, sizeof(s->osend));
1511 s->osend.hEvent = s->hsend;
1512 while (len > 0) {
1513 if (s->hsend)
1514 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1515 else
1516 ret = WriteFile(s->hcom, buf, len, &size, NULL);
1517 if (!ret) {
1518 err = GetLastError();
1519 if (err == ERROR_IO_PENDING) {
1520 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1521 if (ret) {
1522 buf += size;
1523 len -= size;
1524 } else {
1525 break;
1526 }
1527 } else {
1528 break;
1529 }
1530 } else {
1531 buf += size;
1532 len -= size;
1533 }
1534 }
1535 return len1 - len;
1536 }
1537
1538 static int win_chr_read_poll(CharDriverState *chr)
1539 {
1540 WinCharState *s = chr->opaque;
1541
1542 s->max_size = qemu_chr_can_read(chr);
1543 return s->max_size;
1544 }
1545
1546 static void win_chr_readfile(CharDriverState *chr)
1547 {
1548 WinCharState *s = chr->opaque;
1549 int ret, err;
1550 uint8_t buf[READ_BUF_LEN];
1551 DWORD size;
1552
1553 ZeroMemory(&s->orecv, sizeof(s->orecv));
1554 s->orecv.hEvent = s->hrecv;
1555 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1556 if (!ret) {
1557 err = GetLastError();
1558 if (err == ERROR_IO_PENDING) {
1559 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1560 }
1561 }
1562
1563 if (size > 0) {
1564 qemu_chr_read(chr, buf, size);
1565 }
1566 }
1567
1568 static void win_chr_read(CharDriverState *chr)
1569 {
1570 WinCharState *s = chr->opaque;
1571
1572 if (s->len > s->max_size)
1573 s->len = s->max_size;
1574 if (s->len == 0)
1575 return;
1576
1577 win_chr_readfile(chr);
1578 }
1579
1580 static int win_chr_poll(void *opaque)
1581 {
1582 CharDriverState *chr = opaque;
1583 WinCharState *s = chr->opaque;
1584 COMSTAT status;
1585 DWORD comerr;
1586
1587 ClearCommError(s->hcom, &comerr, &status);
1588 if (status.cbInQue > 0) {
1589 s->len = status.cbInQue;
1590 win_chr_read_poll(chr);
1591 win_chr_read(chr);
1592 return 1;
1593 }
1594 return 0;
1595 }
1596
1597 static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
1598 {
1599 const char *filename = qemu_opt_get(opts, "path");
1600 CharDriverState *chr;
1601 WinCharState *s;
1602
1603 chr = qemu_mallocz(sizeof(CharDriverState));
1604 s = qemu_mallocz(sizeof(WinCharState));
1605 chr->opaque = s;
1606 chr->chr_write = win_chr_write;
1607 chr->chr_close = win_chr_close;
1608
1609 if (win_chr_init(chr, filename) < 0) {
1610 free(s);
1611 free(chr);
1612 return NULL;
1613 }
1614 qemu_chr_generic_open(chr);
1615 return chr;
1616 }
1617
1618 static int win_chr_pipe_poll(void *opaque)
1619 {
1620 CharDriverState *chr = opaque;
1621 WinCharState *s = chr->opaque;
1622 DWORD size;
1623
1624 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
1625 if (size > 0) {
1626 s->len = size;
1627 win_chr_read_poll(chr);
1628 win_chr_read(chr);
1629 return 1;
1630 }
1631 return 0;
1632 }
1633
1634 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1635 {
1636 WinCharState *s = chr->opaque;
1637 OVERLAPPED ov;
1638 int ret;
1639 DWORD size;
1640 char openname[256];
1641
1642 s->fpipe = TRUE;
1643
1644 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1645 if (!s->hsend) {
1646 fprintf(stderr, "Failed CreateEvent\n");
1647 goto fail;
1648 }
1649 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1650 if (!s->hrecv) {
1651 fprintf(stderr, "Failed CreateEvent\n");
1652 goto fail;
1653 }
1654
1655 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
1656 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
1657 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
1658 PIPE_WAIT,
1659 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
1660 if (s->hcom == INVALID_HANDLE_VALUE) {
1661 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
1662 s->hcom = NULL;
1663 goto fail;
1664 }
1665
1666 ZeroMemory(&ov, sizeof(ov));
1667 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1668 ret = ConnectNamedPipe(s->hcom, &ov);
1669 if (ret) {
1670 fprintf(stderr, "Failed ConnectNamedPipe\n");
1671 goto fail;
1672 }
1673
1674 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
1675 if (!ret) {
1676 fprintf(stderr, "Failed GetOverlappedResult\n");
1677 if (ov.hEvent) {
1678 CloseHandle(ov.hEvent);
1679 ov.hEvent = NULL;
1680 }
1681 goto fail;
1682 }
1683
1684 if (ov.hEvent) {
1685 CloseHandle(ov.hEvent);
1686 ov.hEvent = NULL;
1687 }
1688 qemu_add_polling_cb(win_chr_pipe_poll, chr);
1689 return 0;
1690
1691 fail:
1692 win_chr_close(chr);
1693 return -1;
1694 }
1695
1696
1697 static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
1698 {
1699 const char *filename = qemu_opt_get(opts, "path");
1700 CharDriverState *chr;
1701 WinCharState *s;
1702
1703 chr = qemu_mallocz(sizeof(CharDriverState));
1704 s = qemu_mallocz(sizeof(WinCharState));
1705 chr->opaque = s;
1706 chr->chr_write = win_chr_write;
1707 chr->chr_close = win_chr_close;
1708
1709 if (win_chr_pipe_init(chr, filename) < 0) {
1710 free(s);
1711 free(chr);
1712 return NULL;
1713 }
1714 qemu_chr_generic_open(chr);
1715 return chr;
1716 }
1717
1718 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
1719 {
1720 CharDriverState *chr;
1721 WinCharState *s;
1722
1723 chr = qemu_mallocz(sizeof(CharDriverState));
1724 s = qemu_mallocz(sizeof(WinCharState));
1725 s->hcom = fd_out;
1726 chr->opaque = s;
1727 chr->chr_write = win_chr_write;
1728 qemu_chr_generic_open(chr);
1729 return chr;
1730 }
1731
1732 static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
1733 {
1734 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
1735 }
1736
1737 static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
1738 {
1739 const char *file_out = qemu_opt_get(opts, "path");
1740 HANDLE fd_out;
1741
1742 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1743 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1744 if (fd_out == INVALID_HANDLE_VALUE)
1745 return NULL;
1746
1747 return qemu_chr_open_win_file(fd_out);
1748 }
1749 #endif /* !_WIN32 */
1750
1751 /***********************************************************/
1752 /* UDP Net console */
1753
1754 typedef struct {
1755 int fd;
1756 uint8_t buf[READ_BUF_LEN];
1757 int bufcnt;
1758 int bufptr;
1759 int max_size;
1760 } NetCharDriver;
1761
1762 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1763 {
1764 NetCharDriver *s = chr->opaque;
1765
1766 return send(s->fd, (const void *)buf, len, 0);
1767 }
1768
1769 static int udp_chr_read_poll(void *opaque)
1770 {
1771 CharDriverState *chr = opaque;
1772 NetCharDriver *s = chr->opaque;
1773
1774 s->max_size = qemu_chr_can_read(chr);
1775
1776 /* If there were any stray characters in the queue process them
1777 * first
1778 */
1779 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
1780 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1781 s->bufptr++;
1782 s->max_size = qemu_chr_can_read(chr);
1783 }
1784 return s->max_size;
1785 }
1786
1787 static void udp_chr_read(void *opaque)
1788 {
1789 CharDriverState *chr = opaque;
1790 NetCharDriver *s = chr->opaque;
1791
1792 if (s->max_size == 0)
1793 return;
1794 s->bufcnt = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
1795 s->bufptr = s->bufcnt;
1796 if (s->bufcnt <= 0)
1797 return;
1798
1799 s->bufptr = 0;
1800 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
1801 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1802 s->bufptr++;
1803 s->max_size = qemu_chr_can_read(chr);
1804 }
1805 }
1806
1807 static void udp_chr_update_read_handler(CharDriverState *chr)
1808 {
1809 NetCharDriver *s = chr->opaque;
1810
1811 if (s->fd >= 0) {
1812 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
1813 udp_chr_read, NULL, chr);
1814 }
1815 }
1816
1817 static void udp_chr_close(CharDriverState *chr)
1818 {
1819 NetCharDriver *s = chr->opaque;
1820 if (s->fd >= 0) {
1821 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1822 closesocket(s->fd);
1823 }
1824 qemu_free(s);
1825 qemu_chr_event(chr, CHR_EVENT_CLOSED);
1826 }
1827
1828 static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
1829 {
1830 CharDriverState *chr = NULL;
1831 NetCharDriver *s = NULL;
1832 int fd = -1;
1833
1834 chr = qemu_mallocz(sizeof(CharDriverState));
1835 s = qemu_mallocz(sizeof(NetCharDriver));
1836
1837 fd = inet_dgram_opts(opts);
1838 if (fd < 0) {
1839 fprintf(stderr, "inet_dgram_opts failed\n");
1840 goto return_err;
1841 }
1842
1843 s->fd = fd;
1844 s->bufcnt = 0;
1845 s->bufptr = 0;
1846 chr->opaque = s;
1847 chr->chr_write = udp_chr_write;
1848 chr->chr_update_read_handler = udp_chr_update_read_handler;
1849 chr->chr_close = udp_chr_close;
1850 return chr;
1851
1852 return_err:
1853 if (chr)
1854 free(chr);
1855 if (s)
1856 free(s);
1857 if (fd >= 0)
1858 closesocket(fd);
1859 return NULL;
1860 }
1861
1862 /***********************************************************/
1863 /* TCP Net console */
1864
1865 typedef struct {
1866 int fd, listen_fd;
1867 int connected;
1868 int max_size;
1869 int do_telnetopt;
1870 int do_nodelay;
1871 int is_unix;
1872 int msgfd;
1873 } TCPCharDriver;
1874
1875 static void tcp_chr_accept(void *opaque);
1876
1877 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1878 {
1879 TCPCharDriver *s = chr->opaque;
1880 if (s->connected) {
1881 return send_all(s->fd, buf, len);
1882 } else {
1883 /* XXX: indicate an error ? */
1884 return len;
1885 }
1886 }
1887
1888 static int tcp_chr_read_poll(void *opaque)
1889 {
1890 CharDriverState *chr = opaque;
1891 TCPCharDriver *s = chr->opaque;
1892 if (!s->connected)
1893 return 0;
1894 s->max_size = qemu_chr_can_read(chr);
1895 return s->max_size;
1896 }
1897
1898 #define IAC 255
1899 #define IAC_BREAK 243
1900 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
1901 TCPCharDriver *s,
1902 uint8_t *buf, int *size)
1903 {
1904 /* Handle any telnet client's basic IAC options to satisfy char by
1905 * char mode with no echo. All IAC options will be removed from
1906 * the buf and the do_telnetopt variable will be used to track the
1907 * state of the width of the IAC information.
1908 *
1909 * IAC commands come in sets of 3 bytes with the exception of the
1910 * "IAC BREAK" command and the double IAC.
1911 */
1912
1913 int i;
1914 int j = 0;
1915
1916 for (i = 0; i < *size; i++) {
1917 if (s->do_telnetopt > 1) {
1918 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
1919 /* Double IAC means send an IAC */
1920 if (j != i)
1921 buf[j] = buf[i];
1922 j++;
1923 s->do_telnetopt = 1;
1924 } else {
1925 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
1926 /* Handle IAC break commands by sending a serial break */
1927 qemu_chr_event(chr, CHR_EVENT_BREAK);
1928 s->do_telnetopt++;
1929 }
1930 s->do_telnetopt++;
1931 }
1932 if (s->do_telnetopt >= 4) {
1933 s->do_telnetopt = 1;
1934 }
1935 } else {
1936 if ((unsigned char)buf[i] == IAC) {
1937 s->do_telnetopt = 2;
1938 } else {
1939 if (j != i)
1940 buf[j] = buf[i];
1941 j++;
1942 }
1943 }
1944 }
1945 *size = j;
1946 }
1947
1948 static int tcp_get_msgfd(CharDriverState *chr)
1949 {
1950 TCPCharDriver *s = chr->opaque;
1951
1952 return s->msgfd;
1953 }
1954
1955 #ifndef _WIN32
1956 static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
1957 {
1958 TCPCharDriver *s = chr->opaque;
1959 struct cmsghdr *cmsg;
1960
1961 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
1962 int fd;
1963
1964 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
1965 cmsg->cmsg_level != SOL_SOCKET ||
1966 cmsg->cmsg_type != SCM_RIGHTS)
1967 continue;
1968
1969 fd = *((int *)CMSG_DATA(cmsg));
1970 if (fd < 0)
1971 continue;
1972
1973 if (s->msgfd != -1)
1974 close(s->msgfd);
1975 s->msgfd = fd;
1976 }
1977 }
1978
1979 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
1980 {
1981 TCPCharDriver *s = chr->opaque;
1982 struct msghdr msg = { NULL, };
1983 struct iovec iov[1];
1984 union {
1985 struct cmsghdr cmsg;
1986 char control[CMSG_SPACE(sizeof(int))];
1987 } msg_control;
1988 ssize_t ret;
1989
1990 iov[0].iov_base = buf;
1991 iov[0].iov_len = len;
1992
1993 msg.msg_iov = iov;
1994 msg.msg_iovlen = 1;
1995 msg.msg_control = &msg_control;
1996 msg.msg_controllen = sizeof(msg_control);
1997
1998 ret = recvmsg(s->fd, &msg, 0);
1999 if (ret > 0 && s->is_unix)
2000 unix_process_msgfd(chr, &msg);
2001
2002 return ret;
2003 }
2004 #else
2005 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2006 {
2007 TCPCharDriver *s = chr->opaque;
2008 return recv(s->fd, buf, len, 0);
2009 }
2010 #endif
2011
2012 static void tcp_chr_read(void *opaque)
2013 {
2014 CharDriverState *chr = opaque;
2015 TCPCharDriver *s = chr->opaque;
2016 uint8_t buf[READ_BUF_LEN];
2017 int len, size;
2018
2019 if (!s->connected || s->max_size <= 0)
2020 return;
2021 len = sizeof(buf);
2022 if (len > s->max_size)
2023 len = s->max_size;
2024 size = tcp_chr_recv(chr, (void *)buf, len);
2025 if (size == 0) {
2026 /* connection closed */
2027 s->connected = 0;
2028 if (s->listen_fd >= 0) {
2029 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2030 }
2031 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2032 closesocket(s->fd);
2033 s->fd = -1;
2034 qemu_chr_event(chr, CHR_EVENT_CLOSED);
2035 } else if (size > 0) {
2036 if (s->do_telnetopt)
2037 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2038 if (size > 0)
2039 qemu_chr_read(chr, buf, size);
2040 if (s->msgfd != -1) {
2041 close(s->msgfd);
2042 s->msgfd = -1;
2043 }
2044 }
2045 }
2046
2047 static void tcp_chr_connect(void *opaque)
2048 {
2049 CharDriverState *chr = opaque;
2050 TCPCharDriver *s = chr->opaque;
2051
2052 s->connected = 1;
2053 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2054 tcp_chr_read, NULL, chr);
2055 qemu_chr_generic_open(chr);
2056 }
2057
2058 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2059 static void tcp_chr_telnet_init(int fd)
2060 {
2061 char buf[3];
2062 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2063 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2064 send(fd, (char *)buf, 3, 0);
2065 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2066 send(fd, (char *)buf, 3, 0);
2067 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
2068 send(fd, (char *)buf, 3, 0);
2069 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
2070 send(fd, (char *)buf, 3, 0);
2071 }
2072
2073 static void socket_set_nodelay(int fd)
2074 {
2075 int val = 1;
2076 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
2077 }
2078
2079 static void tcp_chr_accept(void *opaque)
2080 {
2081 CharDriverState *chr = opaque;
2082 TCPCharDriver *s = chr->opaque;
2083 struct sockaddr_in saddr;
2084 #ifndef _WIN32
2085 struct sockaddr_un uaddr;
2086 #endif
2087 struct sockaddr *addr;
2088 socklen_t len;
2089 int fd;
2090
2091 for(;;) {
2092 #ifndef _WIN32
2093 if (s->is_unix) {
2094 len = sizeof(uaddr);
2095 addr = (struct sockaddr *)&uaddr;
2096 } else
2097 #endif
2098 {
2099 len = sizeof(saddr);
2100 addr = (struct sockaddr *)&saddr;
2101 }
2102 fd = accept(s->listen_fd, addr, &len);
2103 if (fd < 0 && errno != EINTR) {
2104 return;
2105 } else if (fd >= 0) {
2106 if (s->do_telnetopt)
2107 tcp_chr_telnet_init(fd);
2108 break;
2109 }
2110 }
2111 socket_set_nonblock(fd);
2112 if (s->do_nodelay)
2113 socket_set_nodelay(fd);
2114 s->fd = fd;
2115 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2116 tcp_chr_connect(chr);
2117 }
2118
2119 static void tcp_chr_close(CharDriverState *chr)
2120 {
2121 TCPCharDriver *s = chr->opaque;
2122 if (s->fd >= 0) {
2123 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2124 closesocket(s->fd);
2125 }
2126 if (s->listen_fd >= 0) {
2127 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2128 closesocket(s->listen_fd);
2129 }
2130 qemu_free(s);
2131 qemu_chr_event(chr, CHR_EVENT_CLOSED);
2132 }
2133
2134 static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
2135 {
2136 CharDriverState *chr = NULL;
2137 TCPCharDriver *s = NULL;
2138 int fd = -1;
2139 int is_listen;
2140 int is_waitconnect;
2141 int do_nodelay;
2142 int is_unix;
2143 int is_telnet;
2144
2145 is_listen = qemu_opt_get_bool(opts, "server", 0);
2146 is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
2147 is_telnet = qemu_opt_get_bool(opts, "telnet", 0);
2148 do_nodelay = !qemu_opt_get_bool(opts, "delay", 1);
2149 is_unix = qemu_opt_get(opts, "path") != NULL;
2150 if (!is_listen)
2151 is_waitconnect = 0;
2152
2153 chr = qemu_mallocz(sizeof(CharDriverState));
2154 s = qemu_mallocz(sizeof(TCPCharDriver));
2155
2156 if (is_unix) {
2157 if (is_listen) {
2158 fd = unix_listen_opts(opts);
2159 } else {
2160 fd = unix_connect_opts(opts);
2161 }
2162 } else {
2163 if (is_listen) {
2164 fd = inet_listen_opts(opts, 0);
2165 } else {
2166 fd = inet_connect_opts(opts);
2167 }
2168 }
2169 if (fd < 0)
2170 goto fail;
2171
2172 if (!is_waitconnect)
2173 socket_set_nonblock(fd);
2174
2175 s->connected = 0;
2176 s->fd = -1;
2177 s->listen_fd = -1;
2178 s->msgfd = -1;
2179 s->is_unix = is_unix;
2180 s->do_nodelay = do_nodelay && !is_unix;
2181
2182 chr->opaque = s;
2183 chr->chr_write = tcp_chr_write;
2184 chr->chr_close = tcp_chr_close;
2185 chr->get_msgfd = tcp_get_msgfd;
2186
2187 if (is_listen) {
2188 s->listen_fd = fd;
2189 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2190 if (is_telnet)
2191 s->do_telnetopt = 1;
2192
2193 } else {
2194 s->connected = 1;
2195 s->fd = fd;
2196 socket_set_nodelay(fd);
2197 tcp_chr_connect(chr);
2198 }
2199
2200 /* for "info chardev" monitor command */
2201 chr->filename = qemu_malloc(256);
2202 if (is_unix) {
2203 snprintf(chr->filename, 256, "unix:%s%s",
2204 qemu_opt_get(opts, "path"),
2205 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2206 } else if (is_telnet) {
2207 snprintf(chr->filename, 256, "telnet:%s:%s%s",
2208 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2209 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2210 } else {
2211 snprintf(chr->filename, 256, "tcp:%s:%s%s",
2212 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2213 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2214 }
2215
2216 if (is_listen && is_waitconnect) {
2217 printf("QEMU waiting for connection on: %s\n",
2218 chr->filename);
2219 tcp_chr_accept(chr);
2220 socket_set_nonblock(s->listen_fd);
2221 }
2222 return chr;
2223
2224 fail:
2225 if (fd >= 0)
2226 closesocket(fd);
2227 qemu_free(s);
2228 qemu_free(chr);
2229 return NULL;
2230 }
2231
2232 static QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
2233 {
2234 char host[65], port[33], width[8], height[8];
2235 int pos;
2236 const char *p;
2237 QemuOpts *opts;
2238
2239 opts = qemu_opts_create(&qemu_chardev_opts, label, 1);
2240 if (NULL == opts)
2241 return NULL;
2242
2243 if (strstart(filename, "mon:", &p)) {
2244 filename = p;
2245 qemu_opt_set(opts, "mux", "on");
2246 }
2247
2248 if (strcmp(filename, "null") == 0 ||
2249 strcmp(filename, "pty") == 0 ||
2250 strcmp(filename, "msmouse") == 0 ||
2251 strcmp(filename, "braille") == 0 ||
2252 strcmp(filename, "stdio") == 0) {
2253 qemu_opt_set(opts, "backend", filename);
2254 return opts;
2255 }
2256 if (strstart(filename, "vc", &p)) {
2257 qemu_opt_set(opts, "backend", "vc");
2258 if (*p == ':') {
2259 if (sscanf(p+1, "%8[0-9]x%8[0-9]", width, height) == 2) {
2260 /* pixels */
2261 qemu_opt_set(opts, "width", width);
2262 qemu_opt_set(opts, "height", height);
2263 } else if (sscanf(p+1, "%8[0-9]Cx%8[0-9]C", width, height) == 2) {
2264 /* chars */
2265 qemu_opt_set(opts, "cols", width);
2266 qemu_opt_set(opts, "rows", height);
2267 } else {
2268 goto fail;
2269 }
2270 }
2271 return opts;
2272 }
2273 if (strcmp(filename, "con:") == 0) {
2274 qemu_opt_set(opts, "backend", "console");
2275 return opts;
2276 }
2277 if (strstart(filename, "COM", NULL)) {
2278 qemu_opt_set(opts, "backend", "serial");
2279 qemu_opt_set(opts, "path", filename);
2280 return opts;
2281 }
2282 if (strstart(filename, "file:", &p)) {
2283 qemu_opt_set(opts, "backend", "file");
2284 qemu_opt_set(opts, "path", p);
2285 return opts;
2286 }
2287 if (strstart(filename, "pipe:", &p)) {
2288 qemu_opt_set(opts, "backend", "pipe");
2289 qemu_opt_set(opts, "path", p);
2290 return opts;
2291 }
2292 if (strstart(filename, "tcp:", &p) ||
2293 strstart(filename, "telnet:", &p)) {
2294 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2295 host[0] = 0;
2296 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
2297 goto fail;
2298 }
2299 qemu_opt_set(opts, "backend", "socket");
2300 qemu_opt_set(opts, "host", host);
2301 qemu_opt_set(opts, "port", port);
2302 if (p[pos] == ',') {
2303 if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0)
2304 goto fail;
2305 }
2306 if (strstart(filename, "telnet:", &p))
2307 qemu_opt_set(opts, "telnet", "on");
2308 return opts;
2309 }
2310 if (strstart(filename, "udp:", &p)) {
2311 qemu_opt_set(opts, "backend", "udp");
2312 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
2313 host[0] = 0;
2314 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
2315 fprintf(stderr, "udp #1\n");
2316 goto fail;
2317 }
2318 }
2319 qemu_opt_set(opts, "host", host);
2320 qemu_opt_set(opts, "port", port);
2321 if (p[pos] == '@') {
2322 p += pos + 1;
2323 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2324 host[0] = 0;
2325 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
2326 fprintf(stderr, "udp #2\n");
2327 goto fail;
2328 }
2329 }
2330 qemu_opt_set(opts, "localaddr", host);
2331 qemu_opt_set(opts, "localport", port);
2332 }
2333 return opts;
2334 }
2335 if (strstart(filename, "unix:", &p)) {
2336 qemu_opt_set(opts, "backend", "socket");
2337 if (qemu_opts_do_parse(opts, p, "path") != 0)
2338 goto fail;
2339 return opts;
2340 }
2341 if (strstart(filename, "/dev/parport", NULL) ||
2342 strstart(filename, "/dev/ppi", NULL)) {
2343 qemu_opt_set(opts, "backend", "parport");
2344 qemu_opt_set(opts, "path", filename);
2345 return opts;
2346 }
2347 if (strstart(filename, "/dev/", NULL)) {
2348 qemu_opt_set(opts, "backend", "tty");
2349 qemu_opt_set(opts, "path", filename);
2350 return opts;
2351 }
2352
2353 fail:
2354 fprintf(stderr, "%s: fail on \"%s\"\n", __FUNCTION__, filename);
2355 qemu_opts_del(opts);
2356 return NULL;
2357 }
2358
2359 static const struct {
2360 const char *name;
2361 CharDriverState *(*open)(QemuOpts *opts);
2362 } backend_table[] = {
2363 { .name = "null", .open = qemu_chr_open_null },
2364 { .name = "socket", .open = qemu_chr_open_socket },
2365 { .name = "udp", .open = qemu_chr_open_udp },
2366 { .name = "msmouse", .open = qemu_chr_open_msmouse },
2367 { .name = "vc", .open = text_console_init },
2368 #ifdef _WIN32
2369 { .name = "file", .open = qemu_chr_open_win_file_out },
2370 { .name = "pipe", .open = qemu_chr_open_win_pipe },
2371 { .name = "console", .open = qemu_chr_open_win_con },
2372 { .name = "serial", .open = qemu_chr_open_win },
2373 #else
2374 { .name = "file", .open = qemu_chr_open_file_out },
2375 { .name = "pipe", .open = qemu_chr_open_pipe },
2376 { .name = "pty", .open = qemu_chr_open_pty },
2377 { .name = "stdio", .open = qemu_chr_open_stdio },
2378 #endif
2379 #ifdef CONFIG_BRLAPI
2380 { .name = "braille", .open = chr_baum_init },
2381 #endif
2382 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2383 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
2384 { .name = "tty", .open = qemu_chr_open_tty },
2385 #endif
2386 #if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__)
2387 { .name = "parport", .open = qemu_chr_open_pp },
2388 #endif
2389 };
2390
2391 CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
2392 void (*init)(struct CharDriverState *s))
2393 {
2394 CharDriverState *chr;
2395 int i;
2396
2397 if (qemu_opts_id(opts) == NULL) {
2398 fprintf(stderr, "chardev: no id specified\n");
2399 return NULL;
2400 }
2401
2402 for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
2403 if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
2404 break;
2405 }
2406 if (i == ARRAY_SIZE(backend_table)) {
2407 fprintf(stderr, "chardev: backend \"%s\" not found\n",
2408 qemu_opt_get(opts, "backend"));
2409 return NULL;
2410 }
2411
2412 chr = backend_table[i].open(opts);
2413 if (!chr) {
2414 fprintf(stderr, "chardev: opening backend \"%s\" failed\n",
2415 qemu_opt_get(opts, "backend"));
2416 return NULL;
2417 }
2418
2419 if (!chr->filename)
2420 chr->filename = qemu_strdup(qemu_opt_get(opts, "backend"));
2421 chr->init = init;
2422 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2423
2424 if (qemu_opt_get_bool(opts, "mux", 0)) {
2425 CharDriverState *base = chr;
2426 int len = strlen(qemu_opts_id(opts)) + 6;
2427 base->label = qemu_malloc(len);
2428 snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
2429 chr = qemu_chr_open_mux(base);
2430 chr->filename = base->filename;
2431 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2432 }
2433 chr->label = qemu_strdup(qemu_opts_id(opts));
2434 return chr;
2435 }
2436
2437 CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
2438 {
2439 const char *p;
2440 CharDriverState *chr;
2441 QemuOpts *opts;
2442
2443 if (strstart(filename, "chardev:", &p)) {
2444 return qemu_chr_find(p);
2445 }
2446
2447 opts = qemu_chr_parse_compat(label, filename);
2448 if (!opts)
2449 return NULL;
2450
2451 chr = qemu_chr_open_opts(opts, init);
2452 if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
2453 monitor_init(chr, MONITOR_USE_READLINE);
2454 }
2455 return chr;
2456 }
2457
2458 void qemu_chr_close(CharDriverState *chr)
2459 {
2460 QTAILQ_REMOVE(&chardevs, chr, next);
2461 if (chr->chr_close)
2462 chr->chr_close(chr);
2463 qemu_free(chr->filename);
2464 qemu_free(chr->label);
2465 qemu_free(chr);
2466 }
2467
2468 void qemu_chr_info(Monitor *mon)
2469 {
2470 CharDriverState *chr;
2471
2472 QTAILQ_FOREACH(chr, &chardevs, next) {
2473 monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
2474 }
2475 }
2476
2477 CharDriverState *qemu_chr_find(const char *name)
2478 {
2479 CharDriverState *chr;
2480
2481 QTAILQ_FOREACH(chr, &chardevs, next) {
2482 if (strcmp(chr->label, name) != 0)
2483 continue;
2484 return chr;
2485 }
2486 return NULL;
2487 }
Qemu copy for testing