Archipelago » qemu

/*

 * QEMU monitor

 *

 * Copyright (c) 2003-2004 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include <dirent.h>

#include "hw/hw.h"

#include "hw/qdev.h"

#include "hw/usb.h"

#include "hw/pcmcia.h"

#include "hw/pc.h"

#include "hw/pci.h"

#include "hw/watchdog.h"

#include "hw/loader.h"

#include "gdbstub.h"

#include "net.h"

#include "net/slirp.h"

#include "qemu-char.h"

#include "ui/qemu-spice.h"

#include "sysemu.h"

#include "monitor.h"

#include "readline.h"

#include "console.h"

#include "blockdev.h"

#include "audio/audio.h"

#include "disas.h"

#include "balloon.h"

#include "qemu-timer.h"

#include "migration.h"

#include "kvm.h"

#include "acl.h"

#include "qint.h"

#include "qfloat.h"

#include "qlist.h"

#include "qbool.h"

#include "qstring.h"

#include "qjson.h"

#include "json-streamer.h"

#include "json-parser.h"

#include "osdep.h"

#include "cpu.h"

#include "trace.h"

#include "trace/control.h"

#ifdef CONFIG_TRACE_SIMPLE

#include "trace/simple.h"

#endif

#include "ui/qemu-spice.h"

#include "memory.h"

#include "qmp-commands.h"

#include "hmp.h"

/* for pic/irq_info */

#if defined(TARGET_SPARC)

#include "hw/sun4m.h"

#endif

#include "hw/lm32_pic.h"

//#define DEBUG

//#define DEBUG_COMPLETION

/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'O'          option string of the form NAME=VALUE,...

 *              parsed according to QemuOptsList given by its name

 *              Example: 'device:O' uses qemu_device_opts.

 *              Restriction: only lists with empty desc are supported

 *              TODO lift the restriction

 * 'i'          32 bit integer

 * 'l'          target long (32 or 64 bit)

 * 'M'          Non-negative target long (32 or 64 bit), in user mode the

 *              value is multiplied by 2^20 (think Mebibyte)

 * 'o'          octets (aka bytes)

 *              user mode accepts an optional T, t, G, g, M, m, K, k

 *              suffix, which multiplies the value by 2^40 for

 *              suffixes T and t, 2^30 for suffixes G and g, 2^20 for

 *              M and m, 2^10 for K and k

 * 'T'          double

 *              user mode accepts an optional ms, us, ns suffix,

 *              which divides the value by 1e3, 1e6, 1e9, respectively

 * '/'          optional gdb-like print format (like "/10x")

 *

 * '?'          optional type (for all types, except '/')

 * '.'          other form of optional type (for 'i' and 'l')

 * 'b'          boolean

 *              user mode accepts "on" or "off"

 * '-'          optional parameter (eg. '-f')

 *

 */

typedef struct MonitorCompletionData MonitorCompletionData;

struct MonitorCompletionData {

    Monitor *mon;

    void (*user_print)(Monitor *mon, const QObject *data);

};

typedef struct mon_cmd_t {

    const char *name;

    const char *args_type;

    const char *params;

    const char *help;

    void (*user_print)(Monitor *mon, const QObject *data);

    union {

        void (*info)(Monitor *mon);

        void (*cmd)(Monitor *mon, const QDict *qdict);

        int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);

        int  (*cmd_async)(Monitor *mon, const QDict *params,

                          MonitorCompletion *cb, void *opaque);

    } mhandler;

    int flags;

} mon_cmd_t;

/* file descriptors passed via SCM_RIGHTS */

typedef struct mon_fd_t mon_fd_t;

struct mon_fd_t {

    char *name;

    int fd;

    QLIST_ENTRY(mon_fd_t) next;

};

typedef struct MonitorControl {

    QObject *id;

    JSONMessageParser parser;

    int command_mode;

} MonitorControl;

struct Monitor {

    CharDriverState *chr;

    int mux_out;

    int reset_seen;

    int flags;

    int suspend_cnt;

    uint8_t outbuf[1024];

    int outbuf_index;

    ReadLineState *rs;

    MonitorControl *mc;

    CPUArchState *mon_cpu;

    BlockDriverCompletionFunc *password_completion_cb;

    void *password_opaque;

#ifdef CONFIG_DEBUG_MONITOR

    int print_calls_nr;

#endif

    QError *error;

    QLIST_HEAD(,mon_fd_t) fds;

    QLIST_ENTRY(Monitor) entry;

};

#ifdef CONFIG_DEBUG_MONITOR

#define MON_DEBUG(fmt, ...) do {    \

    fprintf(stderr, "Monitor: ");       \

    fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)

static inline void mon_print_count_inc(Monitor *mon)

{

    mon->print_calls_nr++;

}

static inline void mon_print_count_init(Monitor *mon)

{

    mon->print_calls_nr = 0;

}

static inline int mon_print_count_get(const Monitor *mon)

{

    return mon->print_calls_nr;

}

#else /* !CONFIG_DEBUG_MONITOR */

#define MON_DEBUG(fmt, ...) do { } while (0)

static inline void mon_print_count_inc(Monitor *mon) { }

static inline void mon_print_count_init(Monitor *mon) { }

static inline int mon_print_count_get(const Monitor *mon) { return 0; }

#endif /* CONFIG_DEBUG_MONITOR */

/* QMP checker flags */

#define QMP_ACCEPT_UNKNOWNS 1

static QLIST_HEAD(mon_list, Monitor) mon_list;

static mon_cmd_t mon_cmds[];

static mon_cmd_t info_cmds[];

static const mon_cmd_t qmp_cmds[];

Monitor *cur_mon;

Monitor *default_mon;

static void monitor_command_cb(Monitor *mon, const char *cmdline,

                               void *opaque);

static inline int qmp_cmd_mode(const Monitor *mon)

{

    return (mon->mc ? mon->mc->command_mode : 0);

}

/* Return true if in control mode, false otherwise */

static inline int monitor_ctrl_mode(const Monitor *mon)

{

    return (mon->flags & MONITOR_USE_CONTROL);

}

/* Return non-zero iff we have a current monitor, and it is in QMP mode.  */

int monitor_cur_is_qmp(void)

{

    return cur_mon && monitor_ctrl_mode(cur_mon);

}

void monitor_read_command(Monitor *mon, int show_prompt)

{

    if (!mon->rs)

        return;

    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);

    if (show_prompt)

        readline_show_prompt(mon->rs);

}

int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,

                          void *opaque)

{

    if (monitor_ctrl_mode(mon)) {

        qerror_report(QERR_MISSING_PARAMETER, "password");

        return -EINVAL;

    } else if (mon->rs) {

        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);

        /* prompt is printed on return from the command handler */

        return 0;

    } else {

        monitor_printf(mon, "terminal does not support password prompting\n");

        return -ENOTTY;

    }

}

void monitor_flush(Monitor *mon)

{

    if (mon && mon->outbuf_index != 0 && !mon->mux_out) {

        qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);

        mon->outbuf_index = 0;

    }

}

/* flush at every end of line or if the buffer is full */

static void monitor_puts(Monitor *mon, const char *str)

{

    char c;

    for(;;) {

        c = *str++;

        if (c == '\0')

            break;

        if (c == '\n')

            mon->outbuf[mon->outbuf_index++] = '\r';

        mon->outbuf[mon->outbuf_index++] = c;

        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)

            || c == '\n')

            monitor_flush(mon);

    }

}

void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)

{

    char buf[4096];

    if (!mon)

        return;

    mon_print_count_inc(mon);

    if (monitor_ctrl_mode(mon)) {

        return;

    }

    vsnprintf(buf, sizeof(buf), fmt, ap);

    monitor_puts(mon, buf);

}

void monitor_printf(Monitor *mon, const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    monitor_vprintf(mon, fmt, ap);

    va_end(ap);

}

void monitor_print_filename(Monitor *mon, const char *filename)

{

    int i;

    for (i = 0; filename[i]; i++) {

        switch (filename[i]) {

        case ' ':

        case '"':

        case '\\':

            monitor_printf(mon, "\\%c", filename[i]);

            break;

        case '\t':

            monitor_printf(mon, "\\t");

            break;

        case '\r':

            monitor_printf(mon, "\\r");

            break;

        case '\n':

            monitor_printf(mon, "\\n");

            break;

        default:

            monitor_printf(mon, "%c", filename[i]);

            break;

        }

    }

}

static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,

                                              const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    monitor_vprintf((Monitor *)stream, fmt, ap);

    va_end(ap);

    return 0;

}

static void monitor_user_noop(Monitor *mon, const QObject *data) { }

static inline int handler_is_qobject(const mon_cmd_t *cmd)

{

    return cmd->user_print != NULL;

}

static inline bool handler_is_async(const mon_cmd_t *cmd)

{

    return cmd->flags & MONITOR_CMD_ASYNC;

}

static inline int monitor_has_error(const Monitor *mon)

{

    return mon->error != NULL;

}

static void monitor_json_emitter(Monitor *mon, const QObject *data)

{

    QString *json;

    json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :

                                             qobject_to_json(data);

    assert(json != NULL);

    qstring_append_chr(json, '\n');

    monitor_puts(mon, qstring_get_str(json));

    QDECREF(json);

}

static void monitor_protocol_emitter(Monitor *mon, QObject *data)

{

    QDict *qmp;

    trace_monitor_protocol_emitter(mon);

    qmp = qdict_new();

    if (!monitor_has_error(mon)) {

        /* success response */

        if (data) {

            qobject_incref(data);

            qdict_put_obj(qmp, "return", data);

        } else {

            /* return an empty QDict by default */

            qdict_put(qmp, "return", qdict_new());

        }

    } else {

        /* error response */

        qdict_put(mon->error->error, "desc", qerror_human(mon->error));

        qdict_put(qmp, "error", mon->error->error);

        QINCREF(mon->error->error);

        QDECREF(mon->error);

        mon->error = NULL;

    }

    if (mon->mc->id) {

        qdict_put_obj(qmp, "id", mon->mc->id);

        mon->mc->id = NULL;

    }

    monitor_json_emitter(mon, QOBJECT(qmp));

    QDECREF(qmp);

}

static void timestamp_put(QDict *qdict)

{

    int err;

    QObject *obj;

    qemu_timeval tv;

    err = qemu_gettimeofday(&tv);

    if (err < 0)

        return;

    obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "

                                "'microseconds': %" PRId64 " }",

                                (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);

    qdict_put_obj(qdict, "timestamp", obj);

}

static const char *monitor_event_names[] = {

    [QEVENT_SHUTDOWN] = "SHUTDOWN",

    [QEVENT_RESET] = "RESET",

    [QEVENT_POWERDOWN] = "POWERDOWN",

    [QEVENT_STOP] = "STOP",

    [QEVENT_RESUME] = "RESUME",

    [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",

    [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",

    [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",

    [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",

    [QEVENT_RTC_CHANGE] = "RTC_CHANGE",

    [QEVENT_WATCHDOG] = "WATCHDOG",

    [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",

    [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",

    [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",

    [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",

    [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",

    [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",

    [QEVENT_SUSPEND] = "SUSPEND",

    [QEVENT_WAKEUP] = "WAKEUP",

};

QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)

/**

 * monitor_protocol_event(): Generate a Monitor event

 *

 * Event-specific data can be emitted through the (optional) 'data' parameter.

 */

void monitor_protocol_event(MonitorEvent event, QObject *data)

{

    QDict *qmp;

    const char *event_name;

    Monitor *mon;

    assert(event < QEVENT_MAX);

    event_name = monitor_event_names[event];

    assert(event_name != NULL);

    qmp = qdict_new();

    timestamp_put(qmp);

    qdict_put(qmp, "event", qstring_from_str(event_name));

    if (data) {

        qobject_incref(data);

        qdict_put_obj(qmp, "data", data);

    }

    QLIST_FOREACH(mon, &mon_list, entry) {

        if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {

            monitor_json_emitter(mon, QOBJECT(qmp));

        }

    }

    QDECREF(qmp);

}

static int do_qmp_capabilities(Monitor *mon, const QDict *params,

                               QObject **ret_data)

{

    /* Will setup QMP capabilities in the future */

    if (monitor_ctrl_mode(mon)) {

        mon->mc->command_mode = 1;

    }

    return 0;

}

static void handle_user_command(Monitor *mon, const char *cmdline);

char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,

                                int64_t cpu_index, Error **errp)

{

    char *output = NULL;

    Monitor *old_mon, hmp;

    CharDriverState mchar;

    memset(&hmp, 0, sizeof(hmp));

    qemu_chr_init_mem(&mchar);

    hmp.chr = &mchar;

    old_mon = cur_mon;

    cur_mon = &hmp;

    if (has_cpu_index) {

        int ret = monitor_set_cpu(cpu_index);

        if (ret < 0) {

            cur_mon = old_mon;

            error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",

                      "a CPU number");

            goto out;

        }

    }

    handle_user_command(&hmp, command_line);

    cur_mon = old_mon;

    if (qemu_chr_mem_osize(hmp.chr) > 0) {

        QString *str = qemu_chr_mem_to_qs(hmp.chr);

        output = g_strdup(qstring_get_str(str));

        QDECREF(str);

    } else {

        output = g_strdup("");

    }

out:

    qemu_chr_close_mem(hmp.chr);

    return output;

}

static int compare_cmd(const char *name, const char *list)

{

    const char *p, *pstart;

    int len;

    len = strlen(name);

    p = list;

    for(;;) {

        pstart = p;

        p = strchr(p, '|');

        if (!p)

            p = pstart + strlen(pstart);

        if ((p - pstart) == len && !memcmp(pstart, name, len))

            return 1;

        if (*p == '\0')

            break;

        p++;

    }

    return 0;

}

static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,

                          const char *prefix, const char *name)

{

    const mon_cmd_t *cmd;

    for(cmd = cmds; cmd->name != NULL; cmd++) {

        if (!name || !strcmp(name, cmd->name))

            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,

                           cmd->params, cmd->help);

    }

}

static void help_cmd(Monitor *mon, const char *name)

{

    if (name && !strcmp(name, "info")) {

        help_cmd_dump(mon, info_cmds, "info ", NULL);

    } else {

        help_cmd_dump(mon, mon_cmds, "", name);

        if (name && !strcmp(name, "log")) {

            const CPULogItem *item;

            monitor_printf(mon, "Log items (comma separated):\n");

            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");

            for(item = cpu_log_items; item->mask != 0; item++) {

                monitor_printf(mon, "%-10s %s\n", item->name, item->help);

            }

        }

    }

}

static void do_help_cmd(Monitor *mon, const QDict *qdict)

{

    help_cmd(mon, qdict_get_try_str(qdict, "name"));

}

static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)

{

    const char *tp_name = qdict_get_str(qdict, "name");

    bool new_state = qdict_get_bool(qdict, "option");

    int ret = trace_event_set_state(tp_name, new_state);

    if (!ret) {

        monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);

    }

}

#ifdef CONFIG_TRACE_SIMPLE

static void do_trace_file(Monitor *mon, const QDict *qdict)

{

    const char *op = qdict_get_try_str(qdict, "op");

    const char *arg = qdict_get_try_str(qdict, "arg");

    if (!op) {

        st_print_trace_file_status((FILE *)mon, &monitor_fprintf);

    } else if (!strcmp(op, "on")) {

        st_set_trace_file_enabled(true);

    } else if (!strcmp(op, "off")) {

        st_set_trace_file_enabled(false);

    } else if (!strcmp(op, "flush")) {

        st_flush_trace_buffer();

    } else if (!strcmp(op, "set")) {

        if (arg) {

            st_set_trace_file(arg);

        }

    } else {

        monitor_printf(mon, "unexpected argument \"%s\"\n", op);

        help_cmd(mon, "trace-file");

    }

}

#endif

static void user_monitor_complete(void *opaque, QObject *ret_data)

{

    MonitorCompletionData *data = (MonitorCompletionData *)opaque; 

    if (ret_data) {

        data->user_print(data->mon, ret_data);

    }

    monitor_resume(data->mon);

    g_free(data);

}

static void qmp_monitor_complete(void *opaque, QObject *ret_data)

{

    monitor_protocol_emitter(opaque, ret_data);

}

static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,

                                 const QDict *params)

{

    return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);

}

static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,

                                   const QDict *params)

{

    int ret;

    MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));

    cb_data->mon = mon;

    cb_data->user_print = cmd->user_print;

    monitor_suspend(mon);

    ret = cmd->mhandler.cmd_async(mon, params,

                                  user_monitor_complete, cb_data);

    if (ret < 0) {

        monitor_resume(mon);

        g_free(cb_data);

    }

}

static void do_info(Monitor *mon, const QDict *qdict)

{

    const mon_cmd_t *cmd;

    const char *item = qdict_get_try_str(qdict, "item");

    if (!item) {

        goto help;

    }

    for (cmd = info_cmds; cmd->name != NULL; cmd++) {

        if (compare_cmd(item, cmd->name))

            break;

    }

    if (cmd->name == NULL) {

        goto help;

    }

    cmd->mhandler.info(mon);

    return;

help:

    help_cmd(mon, "info");

}

CommandInfoList *qmp_query_commands(Error **errp)

{

    CommandInfoList *info, *cmd_list = NULL;

    const mon_cmd_t *cmd;

    for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {

        info = g_malloc0(sizeof(*info));

        info->value = g_malloc0(sizeof(*info->value));

        info->value->name = g_strdup(cmd->name);

        info->next = cmd_list;

        cmd_list = info;

    }

    return cmd_list;

}

EventInfoList *qmp_query_events(Error **errp)

{

    EventInfoList *info, *ev_list = NULL;

    MonitorEvent e;

    for (e = 0 ; e < QEVENT_MAX ; e++) {

        const char *event_name = monitor_event_names[e];

        assert(event_name != NULL);

        info = g_malloc0(sizeof(*info));

        info->value = g_malloc0(sizeof(*info->value));

        info->value->name = g_strdup(event_name);

        info->next = ev_list;

        ev_list = info;

    }

    return ev_list;

}

/* set the current CPU defined by the user */

int monitor_set_cpu(int cpu_index)

{

    CPUArchState *env;

    for(env = first_cpu; env != NULL; env = env->next_cpu) {

        if (env->cpu_index == cpu_index) {

            cur_mon->mon_cpu = env;

            return 0;

        }

    }

    return -1;

}

static CPUArchState *mon_get_cpu(void)

{

    if (!cur_mon->mon_cpu) {

        monitor_set_cpu(0);

    }

    cpu_synchronize_state(cur_mon->mon_cpu);

    return cur_mon->mon_cpu;

}

int monitor_get_cpu_index(void)

{

    return mon_get_cpu()->cpu_index;

}

static void do_info_registers(Monitor *mon)

{

    CPUArchState *env;

    env = mon_get_cpu();

#ifdef TARGET_I386

    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,

                   X86_DUMP_FPU);

#else

    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,

                   0);

#endif

}

static void do_info_jit(Monitor *mon)

{

    dump_exec_info((FILE *)mon, monitor_fprintf);

}

static void do_info_history(Monitor *mon)

{

    int i;

    const char *str;

    if (!mon->rs)

        return;

    i = 0;

    for(;;) {

        str = readline_get_history(mon->rs, i);

        if (!str)

            break;

        monitor_printf(mon, "%d: '%s'\n", i, str);

        i++;

    }

}

#if defined(TARGET_PPC)

/* XXX: not implemented in other targets */

static void do_info_cpu_stats(Monitor *mon)

{

    CPUArchState *env;

    env = mon_get_cpu();

    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);

}

#endif

#if defined(CONFIG_TRACE_SIMPLE)

static void do_info_trace(Monitor *mon)

{

    st_print_trace((FILE *)mon, &monitor_fprintf);

}

#endif

static void do_trace_print_events(Monitor *mon)

{

    trace_print_events((FILE *)mon, &monitor_fprintf);

}

static int add_graphics_client(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    const char *protocol  = qdict_get_str(qdict, "protocol");

    const char *fdname = qdict_get_str(qdict, "fdname");

    CharDriverState *s;

    if (strcmp(protocol, "spice") == 0) {

        int fd = monitor_get_fd(mon, fdname);

        int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);

        int tls = qdict_get_try_bool(qdict, "tls", 0);

        if (!using_spice) {

            /* correct one? spice isn't a device ,,, */

            qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");

            return -1;

        }

        if (qemu_spice_display_add_client(fd, skipauth, tls) < 0) {

            close(fd);

        }

        return 0;

#ifdef CONFIG_VNC

    } else if (strcmp(protocol, "vnc") == 0) {

        int fd = monitor_get_fd(mon, fdname);

        int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);

        vnc_display_add_client(NULL, fd, skipauth);

        return 0;

#endif

    } else if ((s = qemu_chr_find(protocol)) != NULL) {

        int fd = monitor_get_fd(mon, fdname);

        if (qemu_chr_add_client(s, fd) < 0) {

            qerror_report(QERR_ADD_CLIENT_FAILED);

            return -1;

        }

        return 0;

    }

    qerror_report(QERR_INVALID_PARAMETER, "protocol");

    return -1;

}

static int client_migrate_info(Monitor *mon, const QDict *qdict,

                               MonitorCompletion cb, void *opaque)

{

    const char *protocol = qdict_get_str(qdict, "protocol");

    const char *hostname = qdict_get_str(qdict, "hostname");

    const char *subject  = qdict_get_try_str(qdict, "cert-subject");

    int port             = qdict_get_try_int(qdict, "port", -1);

    int tls_port         = qdict_get_try_int(qdict, "tls-port", -1);

    int ret;

    if (strcmp(protocol, "spice") == 0) {

        if (!using_spice) {

            qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");