Merge with [email protected]:/srv/git/qemu.git

[qemu.git] / qemu-char.c

diff --git a/qemu-char.c b/qemu-char.c
index f8491878be683814b77390428ba263a06437b2d1..be27994012725f3d6c9d42af977d9f516ce0a9e3 100644 (file)
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -23,6 +23,7 @@
  */
 #include "qemu-common.h"
 #include "net.h"
  */
 #include "qemu-common.h"
 #include "net.h"

+#include "monitor.h"

 #include "console.h"
 #include "sysemu.h"
 #include "qemu-timer.h"
 #include "console.h"
 #include "sysemu.h"
 #include "qemu-timer.h"


@@ -30,6 +31,7 @@
 #include "block.h"
 #include "hw/usb.h"
 #include "hw/baum.h"
 #include "block.h"
 #include "hw/usb.h"
 #include "hw/baum.h"

+#include "hw/msmouse.h"

 
 #include <unistd.h>
 #include <fcntl.h>
 
 #include <unistd.h>
 #include <fcntl.h>


@@ -59,12 +61,16 @@
 #include <dirent.h>
 #include <netdb.h>
 #include <sys/select.h>
 #include <dirent.h>
 #include <netdb.h>
 #include <sys/select.h>

-#ifdef _BSD
+#ifdef CONFIG_BSD

 #include <sys/stat.h>
 #ifdef __FreeBSD__
 #include <libutil.h>
 #include <dev/ppbus/ppi.h>
 #include <dev/ppbus/ppbconf.h>
 #include <sys/stat.h>
 #ifdef __FreeBSD__
 #include <libutil.h>
 #include <dev/ppbus/ppi.h>
 #include <dev/ppbus/ppbconf.h>

+#elif defined(__DragonFly__)
+#include <libutil.h>
+#include <dev/misc/ppi/ppi.h>
+#include <bus/ppbus/ppbconf.h>

 #else
 #include <util.h>
 #endif
 #else
 #include <util.h>
 #endif


@@ -100,6 +106,10 @@
 /***********************************************************/
 /* character device */
 
 /***********************************************************/
 /* character device */
 

+static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
+    TAILQ_HEAD_INITIALIZER(chardevs);
+static int initial_reset_issued;
+

 static void qemu_chr_event(CharDriverState *s, int event)
 {
     if (!s->chr_event)
 static void qemu_chr_event(CharDriverState *s, int event)
 {
     if (!s->chr_event)


@@ -117,12 +127,23 @@ static void qemu_chr_reset_bh(void *opaque)
 
 void qemu_chr_reset(CharDriverState *s)
 {
 
 void qemu_chr_reset(CharDriverState *s)
 {

-    if (s->bh == NULL) {
+    if (s->bh == NULL && initial_reset_issued) {

        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
        qemu_bh_schedule(s->bh);
     }
 }
 
        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
        qemu_bh_schedule(s->bh);
     }
 }
 

+void qemu_chr_initial_reset(void)
+{
+    CharDriverState *chr;
+
+    initial_reset_issued = 1;
+
+    TAILQ_FOREACH(chr, &chardevs, next) {
+        qemu_chr_reset(chr);
+    }
+}
+

 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
 {
     return s->chr_write(s, buf, len);
 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
 {
     return s->chr_write(s, buf, len);


@@ -147,6 +168,11 @@ void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
     s->chr_read(s->handler_opaque, buf, len);
 }
 
     s->chr_read(s->handler_opaque, buf, len);
 }
 

+int qemu_chr_get_msgfd(CharDriverState *s)
+{
+    return s->get_msgfd ? s->get_msgfd(s) : -1;
+}
+

 void qemu_chr_accept_input(CharDriverState *s)
 {
     if (s->chr_accept_input)
 void qemu_chr_accept_input(CharDriverState *s)
 {
     if (s->chr_accept_input)


@@ -193,15 +219,11 @@ static CharDriverState *qemu_chr_open_null(void)
     CharDriverState *chr;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     CharDriverState *chr;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     chr->chr_write = null_chr_write;
     return chr;
 }
 
 /* MUX driver for serial I/O splitting */
     chr->chr_write = null_chr_write;
     return chr;
 }
 
 /* MUX driver for serial I/O splitting */

-static int term_timestamps;
-static int64_t term_timestamps_start;

 #define MAX_MUX 4
 #define MUX_BUFFER_SIZE 32     /* Must be a power of 2.  */
 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
 #define MAX_MUX 4
 #define MUX_BUFFER_SIZE 32     /* Must be a power of 2.  */
 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)


@@ -211,12 +233,18 @@ typedef struct {
     IOEventHandler *chr_event[MAX_MUX];
     void *ext_opaque[MAX_MUX];
     CharDriverState *drv;
     IOEventHandler *chr_event[MAX_MUX];
     void *ext_opaque[MAX_MUX];
     CharDriverState *drv;

-    unsigned char buffer[MUX_BUFFER_SIZE];
-    int prod;
-    int cons;

     int mux_cnt;
     int term_got_escape;
     int max_size;
     int mux_cnt;
     int term_got_escape;
     int max_size;

+    /* Intermediate input buffer allows to catch escape sequences even if the
+       currently active device is not accepting any input - but only until it
+       is full as well. */
+    unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
+    int prod[MAX_MUX];
+    int cons[MAX_MUX];
+    int timestamps;
+    int linestart;
+    int64_t timestamps_start;

 } MuxDriver;
 
 
 } MuxDriver;
 
 


@@ -224,23 +252,22 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 {
     MuxDriver *d = chr->opaque;
     int ret;
 {
     MuxDriver *d = chr->opaque;
     int ret;

-    if (!term_timestamps) {
+    if (!d->timestamps) {

         ret = d->drv->chr_write(d->drv, buf, len);
     } else {
         int i;
 
         ret = 0;
         ret = d->drv->chr_write(d->drv, buf, len);
     } else {
         int i;
 
         ret = 0;

-        for(i = 0; i < len; i++) {
-            ret += d->drv->chr_write(d->drv, buf+i, 1);
-            if (buf[i] == '\n') {
+        for (i = 0; i < len; i++) {
+            if (d->linestart) {

                 char buf1[64];
                 int64_t ti;
                 int secs;
 
                 ti = qemu_get_clock(rt_clock);
                 char buf1[64];
                 int64_t ti;
                 int secs;
 
                 ti = qemu_get_clock(rt_clock);

-                if (term_timestamps_start == -1)
-                    term_timestamps_start = ti;
-                ti -= term_timestamps_start;
+                if (d->timestamps_start == -1)
+                    d->timestamps_start = ti;
+                ti -= d->timestamps_start;

                 secs = ti / 1000;
                 snprintf(buf1, sizeof(buf1),
                          "[%02d:%02d:%02d.%03d] ",
                 secs = ti / 1000;
                 snprintf(buf1, sizeof(buf1),
                          "[%02d:%02d:%02d.%03d] ",


@@ -249,6 +276,11 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
                          secs % 60,
                          (int)(ti % 1000));
                 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
                          secs % 60,
                          (int)(ti % 1000));
                 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));

+                d->linestart = 0;
+            }
+            ret += d->drv->chr_write(d->drv, buf+i, 1);
+            if (buf[i] == '\n') {
+                d->linestart = 1;

             }
         }
     }
             }
         }
     }


@@ -292,6 +324,12 @@ static void mux_print_help(CharDriverState *chr)
     }
 }
 
     }
 }
 

+static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
+{
+    if (d->chr_event[mux_nr])
+        d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
+}
+

 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 {
     if (d->term_got_escape) {
 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 {
     if (d->term_got_escape) {


@@ -312,9 +350,9 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
             }
         case 's':
             {
             }
         case 's':
             {

-                int i;
-                for (i = 0; i < nb_drives; i++) {
-                        bdrv_commit(drives_table[i].bdrv);
+                DriveInfo *dinfo;
+                TAILQ_FOREACH(dinfo, &drives, next) {
+                    bdrv_commit(dinfo->bdrv);

                 }
             }
             break;
                 }
             }
             break;


@@ -323,14 +361,17 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
             break;
         case 'c':
             /* Switch to the next registered device */
             break;
         case 'c':
             /* Switch to the next registered device */

+            mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_OUT);

             chr->focus++;
             if (chr->focus >= d->mux_cnt)
                 chr->focus = 0;
             chr->focus++;
             if (chr->focus >= d->mux_cnt)
                 chr->focus = 0;

+            mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_IN);
+            break;
+        case 't':
+            d->timestamps = !d->timestamps;
+            d->timestamps_start = -1;
+            d->linestart = 0;

             break;
             break;

-       case 't':
-           term_timestamps = !term_timestamps;
-           term_timestamps_start = -1;
-           break;

         }
     } else if (ch == term_escape_char) {
         d->term_got_escape = 1;
         }
     } else if (ch == term_escape_char) {
         d->term_got_escape = 1;


@@ -346,11 +387,11 @@ static void mux_chr_accept_input(CharDriverState *chr)
     int m = chr->focus;
     MuxDriver *d = chr->opaque;
 
     int m = chr->focus;
     MuxDriver *d = chr->opaque;
 

-    while (d->prod != d->cons &&
+    while (d->prod[m] != d->cons[m] &&

            d->chr_can_read[m] &&
            d->chr_can_read[m](d->ext_opaque[m])) {
         d->chr_read[m](d->ext_opaque[m],
            d->chr_can_read[m] &&
            d->chr_can_read[m](d->ext_opaque[m])) {
         d->chr_read[m](d->ext_opaque[m],

-                       &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
+                       &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);

     }
 }
 
     }
 }
 


@@ -358,11 +399,12 @@ static int mux_chr_can_read(void *opaque)
 {
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
 {
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;

+    int m = chr->focus;

 
 

-    if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
+    if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)

         return 1;
         return 1;

-    if (d->chr_can_read[chr->focus])
-        return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
+    if (d->chr_can_read[m])
+        return d->chr_can_read[m](d->ext_opaque[m]);

     return 0;
 }
 
     return 0;
 }
 


@@ -377,12 +419,12 @@ static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
 
     for(i = 0; i < size; i++)
         if (mux_proc_byte(chr, d, buf[i])) {
 
     for(i = 0; i < size; i++)
         if (mux_proc_byte(chr, d, buf[i])) {

-            if (d->prod == d->cons &&
+            if (d->prod[m] == d->cons[m] &&

                 d->chr_can_read[m] &&
                 d->chr_can_read[m](d->ext_opaque[m]))
                 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
             else
                 d->chr_can_read[m] &&
                 d->chr_can_read[m](d->ext_opaque[m]))
                 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
             else

-                d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
+                d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];

         }
 }
 
         }
 }
 


@@ -394,8 +436,7 @@ static void mux_chr_event(void *opaque, int event)
 
     /* Send the event to all registered listeners */
     for (i = 0; i < d->mux_cnt; i++)
 
     /* Send the event to all registered listeners */
     for (i = 0; i < d->mux_cnt; i++)

-        if (d->chr_event[i])
-            d->chr_event[i](d->ext_opaque[i], event);
+        mux_chr_send_event(d, i, event);

 }
 
 static void mux_chr_update_read_handler(CharDriverState *chr)
 }
 
 static void mux_chr_update_read_handler(CharDriverState *chr)


@@ -425,13 +466,7 @@ static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
     MuxDriver *d;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     MuxDriver *d;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     d = qemu_mallocz(sizeof(MuxDriver));
     d = qemu_mallocz(sizeof(MuxDriver));

-    if (!d) {
-        free(chr);
-        return NULL;
-    }

 
     chr->opaque = d;
     d->drv = drv;
 
     chr->opaque = d;
     d->drv = drv;


@@ -547,7 +582,7 @@ static void fd_chr_update_read_handler(CharDriverState *chr)
     FDCharDriver *s = chr->opaque;
 
     if (s->fd_in >= 0) {
     FDCharDriver *s = chr->opaque;
 
     if (s->fd_in >= 0) {

-        if (nographic && s->fd_in == 0) {
+        if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {

         } else {
             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
                                  fd_chr_read, NULL, chr);
         } else {
             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
                                  fd_chr_read, NULL, chr);


@@ -560,7 +595,7 @@ static void fd_chr_close(struct CharDriverState *chr)
     FDCharDriver *s = chr->opaque;
 
     if (s->fd_in >= 0) {
     FDCharDriver *s = chr->opaque;
 
     if (s->fd_in >= 0) {

-        if (nographic && s->fd_in == 0) {
+        if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {

         } else {
             qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
         }
         } else {
             qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
         }


@@ -576,13 +611,7 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
     FDCharDriver *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     FDCharDriver *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     s = qemu_mallocz(sizeof(FDCharDriver));
     s = qemu_mallocz(sizeof(FDCharDriver));

-    if (!s) {
-        free(chr);
-        return NULL;
-    }

     s->fd_in = fd_in;
     s->fd_out = fd_out;
     chr->opaque = s;
     s->fd_in = fd_in;
     s->fd_out = fd_out;
     chr->opaque = s;


@@ -696,7 +725,7 @@ static void term_init(void)
     tty.c_oflag |= OPOST;
     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
     /* if graphical mode, we allow Ctrl-C handling */
     tty.c_oflag |= OPOST;
     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
     /* if graphical mode, we allow Ctrl-C handling */

-    if (nographic)
+    if (display_type == DT_NOGRAPHIC)

         tty.c_lflag &= ~ISIG;
     tty.c_cflag &= ~(CSIZE|PARENB);
     tty.c_cflag |= CS8;
         tty.c_lflag &= ~ISIG;
     tty.c_cflag &= ~(CSIZE|PARENB);
     tty.c_cflag |= CS8;


@@ -736,8 +765,8 @@ static CharDriverState *qemu_chr_open_stdio(void)
 
 #ifdef __sun__
 /* Once Solaris has openpty(), this is going to be removed. */
 
 #ifdef __sun__
 /* Once Solaris has openpty(), this is going to be removed. */

-int openpty(int *amaster, int *aslave, char *name,
-            struct termios *termp, struct winsize *winp)
+static int openpty(int *amaster, int *aslave, char *name,
+                   struct termios *termp, struct winsize *winp)

 {
         const char *slave;
         int mfd = -1, sfd = -1;
 {
         const char *slave;
         int mfd = -1, sfd = -1;


@@ -777,7 +806,7 @@ err:
         return -1;
 }
 
         return -1;
 }
 

-void cfmakeraw (struct termios *termios_p)
+static void cfmakeraw (struct termios *termios_p)

 {
         termios_p->c_iflag &=
                 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
 {
         termios_p->c_iflag &=
                 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);


@@ -792,7 +821,7 @@ void cfmakeraw (struct termios *termios_p)
 #endif
 
 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 #endif
 
 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \

-    || defined(__NetBSD__) || defined(__OpenBSD__)
+    || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)

 
 typedef struct {
     int fd;
 
 typedef struct {
     int fd;


@@ -911,6 +940,8 @@ static void pty_chr_close(struct CharDriverState *chr)
 
     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
     close(s->fd);
 
     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
     close(s->fd);

+    qemu_del_timer(s->timer);
+    qemu_free_timer(s->timer);

     qemu_free(s);
 }
 
     qemu_free(s);
 }
 


@@ -920,7 +951,7 @@ static CharDriverState *qemu_chr_open_pty(void)
     PtyCharDriver *s;
     struct termios tty;
     int slave_fd, len;
     PtyCharDriver *s;
     struct termios tty;
     int slave_fd, len;

-#if defined(__OpenBSD__)
+#if defined(__OpenBSD__) || defined(__DragonFly__)

     char pty_name[PATH_MAX];
 #define q_ptsname(x) pty_name
 #else
     char pty_name[PATH_MAX];
 #define q_ptsname(x) pty_name
 #else


@@ -929,13 +960,7 @@ static CharDriverState *qemu_chr_open_pty(void)
 #endif
 
     chr = qemu_mallocz(sizeof(CharDriverState));
 #endif
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     s = qemu_mallocz(sizeof(PtyCharDriver));
     s = qemu_mallocz(sizeof(PtyCharDriver));

-    if (!s) {
-        qemu_free(chr);
-        return NULL;
-    }

 
     if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
         return NULL;
 
     if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
         return NULL;


@@ -1067,17 +1092,17 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
             int *targ = (int *)arg;
             ioctl(s->fd_in, TIOCMGET, &sarg);
             *targ = 0;
             int *targ = (int *)arg;
             ioctl(s->fd_in, TIOCMGET, &sarg);
             *targ = 0;

-            if (sarg | TIOCM_CTS)
+            if (sarg & TIOCM_CTS)

                 *targ |= CHR_TIOCM_CTS;
                 *targ |= CHR_TIOCM_CTS;

-            if (sarg | TIOCM_CAR)
+            if (sarg & TIOCM_CAR)

                 *targ |= CHR_TIOCM_CAR;
                 *targ |= CHR_TIOCM_CAR;

-            if (sarg | TIOCM_DSR)
+            if (sarg & TIOCM_DSR)

                 *targ |= CHR_TIOCM_DSR;
                 *targ |= CHR_TIOCM_DSR;

-            if (sarg | TIOCM_RI)
+            if (sarg & TIOCM_RI)

                 *targ |= CHR_TIOCM_RI;
                 *targ |= CHR_TIOCM_RI;

-            if (sarg | TIOCM_DTR)
+            if (sarg & TIOCM_DTR)

                 *targ |= CHR_TIOCM_DTR;
                 *targ |= CHR_TIOCM_DTR;

-            if (sarg | TIOCM_RTS)
+            if (sarg & TIOCM_RTS)

                 *targ |= CHR_TIOCM_RTS;
         }
         break;
                 *targ |= CHR_TIOCM_RTS;
         }
         break;


@@ -1085,9 +1110,20 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
         {
             int sarg = *(int *)arg;
             int targ = 0;
         {
             int sarg = *(int *)arg;
             int targ = 0;

-            if (sarg | CHR_TIOCM_DTR)
+            ioctl(s->fd_in, TIOCMGET, &targ);
+            targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
+                     | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
+            if (sarg & CHR_TIOCM_CTS)
+                targ |= TIOCM_CTS;
+            if (sarg & CHR_TIOCM_CAR)
+                targ |= TIOCM_CAR;
+            if (sarg & CHR_TIOCM_DSR)
+                targ |= TIOCM_DSR;
+            if (sarg & CHR_TIOCM_RI)
+                targ |= TIOCM_RI;
+            if (sarg & CHR_TIOCM_DTR)

                 targ |= TIOCM_DTR;
                 targ |= TIOCM_DTR;

-            if (sarg | CHR_TIOCM_RTS)
+            if (sarg & CHR_TIOCM_RTS)

                 targ |= TIOCM_RTS;
             ioctl(s->fd_in, TIOCMSET, &targ);
         }
                 targ |= TIOCM_RTS;
             ioctl(s->fd_in, TIOCMSET, &targ);
         }


@@ -1246,19 +1282,10 @@ static CharDriverState *qemu_chr_open_pp(const char *filename)
     }
 
     drv = qemu_mallocz(sizeof(ParallelCharDriver));
     }
 
     drv = qemu_mallocz(sizeof(ParallelCharDriver));

-    if (!drv) {
-        close(fd);
-        return NULL;
-    }

     drv->fd = fd;
     drv->mode = IEEE1284_MODE_COMPAT;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     drv->fd = fd;
     drv->mode = IEEE1284_MODE_COMPAT;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr) {
-       qemu_free(drv);
-        close(fd);
-        return NULL;
-    }

     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;
     chr->chr_close = pp_close;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;
     chr->chr_close = pp_close;


@@ -1270,7 +1297,7 @@ static CharDriverState *qemu_chr_open_pp(const char *filename)
 }
 #endif /* __linux__ */
 
 }
 #endif /* __linux__ */
 

-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__DragonFly__)

 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 {
     int fd = (int)chr->opaque;
 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 {
     int fd = (int)chr->opaque;


@@ -1318,10 +1345,6 @@ static CharDriverState *qemu_chr_open_pp(const char *filename)
         return NULL;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
         return NULL;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr) {
-        close(fd);
-        return NULL;
-    }

     chr->opaque = (void *)fd;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;
     chr->opaque = (void *)fd;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;


@@ -1535,13 +1558,7 @@ static CharDriverState *qemu_chr_open_win(const char *filename)
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     s = qemu_mallocz(sizeof(WinCharState));
     s = qemu_mallocz(sizeof(WinCharState));

-    if (!s) {
-        free(chr);
-        return NULL;
-    }

     chr->opaque = s;
     chr->chr_write = win_chr_write;
     chr->chr_close = win_chr_close;
     chr->opaque = s;
     chr->chr_write = win_chr_write;
     chr->chr_close = win_chr_close;


@@ -1640,13 +1657,7 @@ static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     s = qemu_mallocz(sizeof(WinCharState));
     s = qemu_mallocz(sizeof(WinCharState));

-    if (!s) {
-        free(chr);
-        return NULL;
-    }

     chr->opaque = s;
     chr->chr_write = win_chr_write;
     chr->chr_close = win_chr_close;
     chr->opaque = s;
     chr->chr_write = win_chr_write;
     chr->chr_close = win_chr_close;


@@ -1666,13 +1677,7 @@ static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     WinCharState *s;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        return NULL;

     s = qemu_mallocz(sizeof(WinCharState));
     s = qemu_mallocz(sizeof(WinCharState));

-    if (!s) {
-        free(chr);
-        return NULL;
-    }

     s->hcom = fd_out;
     chr->opaque = s;
     chr->chr_write = win_chr_write;
     s->hcom = fd_out;
     chr->opaque = s;
     chr->chr_write = win_chr_write;


@@ -1714,7 +1719,7 @@ static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 {
     NetCharDriver *s = chr->opaque;
 
 {
     NetCharDriver *s = chr->opaque;
 

-    return sendto(s->fd, buf, len, 0,
+    return sendto(s->fd, (const void *)buf, len, 0,

                   (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
 }
 
                   (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
 }
 


@@ -1743,7 +1748,7 @@ static void udp_chr_read(void *opaque)
 
     if (s->max_size == 0)
         return;
 
     if (s->max_size == 0)
         return;

-    s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
+    s->bufcnt = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);

     s->bufptr = s->bufcnt;
     if (s->bufcnt <= 0)
         return;
     s->bufptr = s->bufcnt;
     if (s->bufcnt <= 0)
         return;


@@ -1766,6 +1771,16 @@ static void udp_chr_update_read_handler(CharDriverState *chr)
     }
 }
 
     }
 }
 

+static void udp_chr_close(CharDriverState *chr)
+{
+    NetCharDriver *s = chr->opaque;
+    if (s->fd >= 0) {
+        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
+        closesocket(s->fd);
+    }
+    qemu_free(s);
+}
+

 static CharDriverState *qemu_chr_open_udp(const char *def)
 {
     CharDriverState *chr = NULL;
 static CharDriverState *qemu_chr_open_udp(const char *def)
 {
     CharDriverState *chr = NULL;


@@ -1774,11 +1789,7 @@ static CharDriverState *qemu_chr_open_udp(const char *def)
     struct sockaddr_in saddr;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
     struct sockaddr_in saddr;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        goto return_err;

     s = qemu_mallocz(sizeof(NetCharDriver));
     s = qemu_mallocz(sizeof(NetCharDriver));

-    if (!s)
-        goto return_err;

 
     fd = socket(PF_INET, SOCK_DGRAM, 0);
     if (fd < 0) {
 
     fd = socket(PF_INET, SOCK_DGRAM, 0);
     if (fd < 0) {


@@ -1803,6 +1814,7 @@ static CharDriverState *qemu_chr_open_udp(const char *def)
     chr->opaque = s;
     chr->chr_write = udp_chr_write;
     chr->chr_update_read_handler = udp_chr_update_read_handler;
     chr->opaque = s;
     chr->chr_write = udp_chr_write;
     chr->chr_update_read_handler = udp_chr_update_read_handler;

+    chr->chr_close = udp_chr_close;

     return chr;
 
 return_err:
     return chr;
 
 return_err:


@@ -1825,6 +1837,7 @@ typedef struct {
     int do_telnetopt;
     int do_nodelay;
     int is_unix;
     int do_telnetopt;
     int do_nodelay;
     int is_unix;

+    int msgfd;

 } TCPCharDriver;
 
 static void tcp_chr_accept(void *opaque);
 } TCPCharDriver;
 
 static void tcp_chr_accept(void *opaque);


@@ -1900,6 +1913,70 @@ static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
     *size = j;
 }
 
     *size = j;
 }
 

+static int tcp_get_msgfd(CharDriverState *chr)
+{
+    TCPCharDriver *s = chr->opaque;
+
+    return s->msgfd;
+}
+
+#ifndef _WIN32
+static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
+{
+    TCPCharDriver *s = chr->opaque;
+    struct cmsghdr *cmsg;
+
+    for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
+        int fd;
+
+        if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
+            cmsg->cmsg_level != SOL_SOCKET ||
+            cmsg->cmsg_type != SCM_RIGHTS)
+            continue;
+
+        fd = *((int *)CMSG_DATA(cmsg));
+        if (fd < 0)
+            continue;
+
+        if (s->msgfd != -1)
+            close(s->msgfd);
+        s->msgfd = fd;
+    }
+}
+
+static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
+{
+    TCPCharDriver *s = chr->opaque;
+    struct msghdr msg = { NULL, };
+    struct iovec iov[1];
+    union {
+        struct cmsghdr cmsg;
+        char control[CMSG_SPACE(sizeof(int))];
+    } msg_control;
+    ssize_t ret;
+
+    iov[0].iov_base = buf;
+    iov[0].iov_len = len;
+
+    msg.msg_iov = iov;
+    msg.msg_iovlen = 1;
+    msg.msg_control = &msg_control;
+    msg.msg_controllen = sizeof(msg_control);
+
+    ret = recvmsg(s->fd, &msg, 0);
+    if (ret > 0 && s->is_unix)
+        unix_process_msgfd(chr, &msg);
+
+    return ret;
+}
+#else
+static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
+{
+    TCPCharDriver *s = chr->opaque;
+    return recv(s->fd, buf, len, 0);
+}
+#endif
+

 static void tcp_chr_read(void *opaque)
 {
     CharDriverState *chr = opaque;
 static void tcp_chr_read(void *opaque)
 {
     CharDriverState *chr = opaque;


@@ -1912,7 +1989,7 @@ static void tcp_chr_read(void *opaque)
     len = sizeof(buf);
     if (len > s->max_size)
         len = s->max_size;
     len = sizeof(buf);
     if (len > s->max_size)
         len = s->max_size;

-    size = recv(s->fd, buf, len, 0);
+    size = tcp_chr_recv(chr, (void *)buf, len);

     if (size == 0) {
         /* connection closed */
         s->connected = 0;
     if (size == 0) {
         /* connection closed */
         s->connected = 0;


@@ -1927,6 +2004,10 @@ static void tcp_chr_read(void *opaque)
             tcp_chr_process_IAC_bytes(chr, s, buf, &size);
         if (size > 0)
             qemu_chr_read(chr, buf, size);
             tcp_chr_process_IAC_bytes(chr, s, buf, &size);
         if (size > 0)
             qemu_chr_read(chr, buf, size);

+        if (s->msgfd != -1) {
+            close(s->msgfd);
+            s->msgfd = -1;
+        }

     }
 }
 
     }
 }
 


@@ -2005,10 +2086,14 @@ static void tcp_chr_accept(void *opaque)
 static void tcp_chr_close(CharDriverState *chr)
 {
     TCPCharDriver *s = chr->opaque;
 static void tcp_chr_close(CharDriverState *chr)
 {
     TCPCharDriver *s = chr->opaque;

-    if (s->fd >= 0)
+    if (s->fd >= 0) {
+        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);

         closesocket(s->fd);
         closesocket(s->fd);

-    if (s->listen_fd >= 0)
+    }
+    if (s->listen_fd >= 0) {
+        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);

         closesocket(s->listen_fd);
         closesocket(s->listen_fd);

+    }

     qemu_free(s);
 }
 
     qemu_free(s);
 }
 


@@ -2035,6 +2120,10 @@ static CharDriverState *qemu_chr_open_tcp(const char *host_str,
             do_nodelay = 1;
         } else if (!strncmp(ptr,"to=",3)) {
             /* nothing, inet_listen() parses this one */;
             do_nodelay = 1;
         } else if (!strncmp(ptr,"to=",3)) {
             /* nothing, inet_listen() parses this one */;

+        } else if (!strncmp(ptr,"ipv4",4)) {
+            /* nothing, inet_connect() and inet_listen() parse this one */;
+        } else if (!strncmp(ptr,"ipv6",4)) {
+            /* nothing, inet_connect() and inet_listen() parse this one */;

         } else {
             printf("Unknown option: %s\n", ptr);
             goto fail;
         } else {
             printf("Unknown option: %s\n", ptr);
             goto fail;


@@ -2044,11 +2133,7 @@ static CharDriverState *qemu_chr_open_tcp(const char *host_str,
         is_waitconnect = 0;
 
     chr = qemu_mallocz(sizeof(CharDriverState));
         is_waitconnect = 0;
 
     chr = qemu_mallocz(sizeof(CharDriverState));

-    if (!chr)
-        goto fail;

     s = qemu_mallocz(sizeof(TCPCharDriver));
     s = qemu_mallocz(sizeof(TCPCharDriver));

-    if (!s)
-        goto fail;

 
     if (is_listen) {
         chr->filename = qemu_malloc(256);
 
     if (is_listen) {
         chr->filename = qemu_malloc(256);


@@ -2084,12 +2169,14 @@ static CharDriverState *qemu_chr_open_tcp(const char *host_str,
     s->connected = 0;
     s->fd = -1;
     s->listen_fd = -1;
     s->connected = 0;
     s->fd = -1;
     s->listen_fd = -1;

+    s->msgfd = -1;

     s->is_unix = is_unix;
     s->do_nodelay = do_nodelay && !is_unix;
 
     chr->opaque = s;
     chr->chr_write = tcp_chr_write;
     chr->chr_close = tcp_chr_close;
     s->is_unix = is_unix;
     s->do_nodelay = do_nodelay && !is_unix;
 
     chr->opaque = s;
     chr->chr_write = tcp_chr_write;
     chr->chr_close = tcp_chr_close;

+    chr->get_msgfd = tcp_get_msgfd;

 
     if (is_listen) {
         s->listen_fd = fd;
 
     if (is_listen) {
         s->listen_fd = fd;


@@ -2119,16 +2206,13 @@ static CharDriverState *qemu_chr_open_tcp(const char *host_str,
     return NULL;
 }
 
     return NULL;
 }
 

-static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs
-= TAILQ_HEAD_INITIALIZER(chardevs);
-

 CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
 {
     const char *p;
     CharDriverState *chr;
 
     if (!strcmp(filename, "vc")) {
 CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
 {
     const char *p;
     CharDriverState *chr;
 
     if (!strcmp(filename, "vc")) {

-        chr = text_console_init(0);
+        chr = text_console_init(NULL);

     } else
     if (strstart(filename, "vc:", &p)) {
         chr = text_console_init(p);
     } else
     if (strstart(filename, "vc:", &p)) {
         chr = text_console_init(p);


@@ -2149,10 +2233,12 @@ CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*i
         chr = qemu_chr_open(label, p, NULL);
         if (chr) {
             chr = qemu_chr_open_mux(chr);
         chr = qemu_chr_open(label, p, NULL);
         if (chr) {
             chr = qemu_chr_open_mux(chr);

-            monitor_init(chr, !nographic);
+            monitor_init(chr, MONITOR_USE_READLINE);

         } else {
             printf("Unable to open driver: %s\n", p);
         }
         } else {
             printf("Unable to open driver: %s\n", p);
         }

+    } else if (!strcmp(filename, "msmouse")) {
+        chr = qemu_chr_open_msmouse();

     } else
 #ifndef _WIN32
     if (strstart(filename, "unix:", &p)) {
     } else
 #ifndef _WIN32
     if (strstart(filename, "unix:", &p)) {


@@ -2170,13 +2256,13 @@ CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*i
     if (strstart(filename, "/dev/parport", NULL)) {
         chr = qemu_chr_open_pp(filename);
     } else
     if (strstart(filename, "/dev/parport", NULL)) {
         chr = qemu_chr_open_pp(filename);
     } else

-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__)

     if (strstart(filename, "/dev/ppi", NULL)) {
         chr = qemu_chr_open_pp(filename);
     } else
 #endif
 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
     if (strstart(filename, "/dev/ppi", NULL)) {
         chr = qemu_chr_open_pp(filename);
     } else
 #endif
 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \

-    || defined(__NetBSD__) || defined(__OpenBSD__)
+    || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)

     if (strstart(filename, "/dev/", NULL)) {
         chr = qemu_chr_open_tty(filename);
     } else
     if (strstart(filename, "/dev/", NULL)) {
         chr = qemu_chr_open_tty(filename);
     } else


@@ -2224,11 +2310,11 @@ void qemu_chr_close(CharDriverState *chr)
     qemu_free(chr);
 }
 
     qemu_free(chr);
 }
 

-void qemu_chr_info(void)
+void qemu_chr_info(Monitor *mon)

 {
     CharDriverState *chr;
 
     TAILQ_FOREACH(chr, &chardevs, next) {
 {
     CharDriverState *chr;
 
     TAILQ_FOREACH(chr, &chardevs, next) {

-        term_printf("%s: filename=%s\n", chr->label, chr->filename);
+        monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);

     }
 }
     }
 }