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