avoid TABs in files that only contain a few

[qemu.git] / ui / vnc.c

diff --git a/ui/vnc.c b/ui/vnc.c
index 93731accb6b4165352a8139582e6aa5a179beaff..9e4b2beb711a37585f69bd8fedab7cbfcc23b479 100644 (file)
--- a/ui/vnc.c
+++ b/ui/vnc.c
@@ -30,15 +30,15 @@
 #include "trace.h"
 #include "sysemu/sysemu.h"
 #include "qemu/error-report.h"
 #include "trace.h"
 #include "sysemu/sysemu.h"
 #include "qemu/error-report.h"

+#include "qemu/option.h"

 #include "qemu/sockets.h"
 #include "qemu/timer.h"
 #include "qemu/acl.h"
 #include "qemu/config-file.h"
 #include "qemu/sockets.h"
 #include "qemu/timer.h"
 #include "qemu/acl.h"
 #include "qemu/config-file.h"

-#include "qapi/qmp/qerror.h"
-#include "qapi/qmp/types.h"
-#include "qmp-commands.h"
+#include "qapi/qapi-events.h"
+#include "qapi/error.h"
+#include "qapi/qapi-commands-ui.h"

 #include "ui/input.h"
 #include "ui/input.h"

-#include "qapi-event.h"

 #include "crypto/hash.h"
 #include "crypto/tlscredsanon.h"
 #include "crypto/tlscredsx509.h"
 #include "crypto/hash.h"
 #include "crypto/tlscredsanon.h"
 #include "crypto/tlscredsx509.h"


@@ -296,14 +296,13 @@ static void vnc_qmp_event(VncState *vs, QAPIEvent event)
 
     switch (event) {
     case QAPI_EVENT_VNC_CONNECTED:
 
     switch (event) {
     case QAPI_EVENT_VNC_CONNECTED:

-        qapi_event_send_vnc_connected(si, qapi_VncClientInfo_base(vs->info),
-                                      &error_abort);
+        qapi_event_send_vnc_connected(si, qapi_VncClientInfo_base(vs->info));

         break;
     case QAPI_EVENT_VNC_INITIALIZED:
         break;
     case QAPI_EVENT_VNC_INITIALIZED:

-        qapi_event_send_vnc_initialized(si, vs->info, &error_abort);
+        qapi_event_send_vnc_initialized(si, vs->info);

         break;
     case QAPI_EVENT_VNC_DISCONNECTED:
         break;
     case QAPI_EVENT_VNC_DISCONNECTED:

-        qapi_event_send_vnc_disconnected(si, vs->info, &error_abort);
+        qapi_event_send_vnc_disconnected(si, vs->info);

         break;
     default:
         break;
         break;
     default:
         break;


@@ -746,9 +745,19 @@ static void vnc_update_server_surface(VncDisplay *vd)
 static void vnc_dpy_switch(DisplayChangeListener *dcl,
                            DisplaySurface *surface)
 {
 static void vnc_dpy_switch(DisplayChangeListener *dcl,
                            DisplaySurface *surface)
 {

+    static const char placeholder_msg[] =
+        "Display output is not active.";
+    static DisplaySurface *placeholder;

     VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
     VncState *vs;
 
     VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
     VncState *vs;
 

+    if (surface == NULL) {
+        if (placeholder == NULL) {
+            placeholder = qemu_create_message_surface(640, 480, placeholder_msg);
+        }
+        surface = placeholder;
+    }
+

     vnc_abort_display_jobs(vd);
     vd->ds = surface;
 
     vnc_abort_display_jobs(vd);
     vd->ds = surface;
 


@@ -982,14 +991,7 @@ static void vnc_update_throttle_offset(VncState *vs)
         vs->client_width * vs->client_height * vs->client_pf.bytes_per_pixel;
 
     if (vs->audio_cap) {
         vs->client_width * vs->client_height * vs->client_pf.bytes_per_pixel;
 
     if (vs->audio_cap) {

-        int freq = vs->as.freq;
-        /* We don't limit freq when reading settings from client, so
-         * it could be upto MAX_INT in size. 48khz is a sensible
-         * upper bound for trustworthy clients */

         int bps;
         int bps;

-        if (freq > 48000) {
-            freq = 48000;
-        }

         switch (vs->as.fmt) {
         default:
         case  AUD_FMT_U8:
         switch (vs->as.fmt) {
         default:
         case  AUD_FMT_U8:


@@ -1005,7 +1007,7 @@ static void vnc_update_throttle_offset(VncState *vs)
             bps = 4;
             break;
         }
             bps = 4;
             break;
         }

-        offset += freq * bps * vs->as.nchannels;
+        offset += vs->as.freq * bps * vs->as.nchannels;

     }
 
     /* Put a floor of 1MB on offset, so that if we have a large pending
     }
 
     /* Put a floor of 1MB on offset, so that if we have a large pending


@@ -1135,6 +1137,7 @@ static void audio_capture_notify(void *opaque, audcnotification_e cmd)
 {
     VncState *vs = opaque;
 
 {
     VncState *vs = opaque;
 

+    assert(vs->magic == VNC_MAGIC);

     switch (cmd) {
     case AUD_CNOTIFY_DISABLE:
         vnc_lock_output(vs);
     switch (cmd) {
     case AUD_CNOTIFY_DISABLE:
         vnc_lock_output(vs);


@@ -1164,6 +1167,7 @@ static void audio_capture(void *opaque, void *buf, int size)
 {
     VncState *vs = opaque;
 
 {
     VncState *vs = opaque;
 

+    assert(vs->magic == VNC_MAGIC);

     vnc_lock_output(vs);
     if (vs->output.offset < vs->throttle_output_offset) {
         vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
     vnc_lock_output(vs);
     if (vs->output.offset < vs->throttle_output_offset) {
         vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);


@@ -1272,6 +1276,7 @@ void vnc_disconnect_finish(VncState *vs)
     vs->ioc = NULL;
     object_unref(OBJECT(vs->sioc));
     vs->sioc = NULL;
     vs->ioc = NULL;
     object_unref(OBJECT(vs->sioc));
     vs->sioc = NULL;

+    vs->magic = 0;

     g_free(vs);
 }
 
     g_free(vs);
 }
 


@@ -1411,7 +1416,7 @@ static void vnc_client_write_locked(VncState *vs)
 
 static void vnc_client_write(VncState *vs)
 {
 
 static void vnc_client_write(VncState *vs)
 {

-
+    assert(vs->magic == VNC_MAGIC);

     vnc_lock_output(vs);
     if (vs->output.offset) {
         vnc_client_write_locked(vs);
     vnc_lock_output(vs);
     if (vs->output.offset) {
         vnc_client_write_locked(vs);


@@ -1484,6 +1489,7 @@ static void vnc_jobs_bh(void *opaque)
 {
     VncState *vs = opaque;
 
 {
     VncState *vs = opaque;
 

+    assert(vs->magic == VNC_MAGIC);

     vnc_jobs_consume_buffer(vs);
 }
 
     vnc_jobs_consume_buffer(vs);
 }
 


@@ -1534,14 +1540,24 @@ gboolean vnc_client_io(QIOChannel *ioc G_GNUC_UNUSED,
                        GIOCondition condition, void *opaque)
 {
     VncState *vs = opaque;
                        GIOCondition condition, void *opaque)
 {
     VncState *vs = opaque;

+
+    assert(vs->magic == VNC_MAGIC);

     if (condition & G_IO_IN) {
         if (vnc_client_read(vs) < 0) {
     if (condition & G_IO_IN) {
         if (vnc_client_read(vs) < 0) {

+            /* vs is free()ed here */

             return TRUE;
         }
     }
     if (condition & G_IO_OUT) {
         vnc_client_write(vs);
     }
             return TRUE;
         }
     }
     if (condition & G_IO_OUT) {
         vnc_client_write(vs);
     }

+
+    if (vs->disconnecting) {
+        if (vs->ioc_tag != 0) {
+            g_source_remove(vs->ioc_tag);
+        }
+        vs->ioc_tag = 0;
+    }

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -1557,6 +1573,7 @@ gboolean vnc_client_io(QIOChannel *ioc G_GNUC_UNUSED,
 
 void vnc_write(VncState *vs, const void *data, size_t len)
 {
 
 void vnc_write(VncState *vs, const void *data, size_t len)
 {

+    assert(vs->magic == VNC_MAGIC);

     if (vs->disconnecting) {
         return;
     }
     if (vs->disconnecting) {
         return;
     }


@@ -1572,8 +1589,8 @@ void vnc_write(VncState *vs, const void *data, size_t len)
      * handshake, or from the job thread's VncState clone
      */
     if (vs->throttle_output_offset != 0 &&
      * handshake, or from the job thread's VncState clone
      */
     if (vs->throttle_output_offset != 0 &&

-        vs->output.offset > (vs->throttle_output_offset *
-                             VNC_THROTTLE_OUTPUT_LIMIT_SCALE)) {
+        (vs->output.offset / VNC_THROTTLE_OUTPUT_LIMIT_SCALE) >
+        vs->throttle_output_offset) {

         trace_vnc_client_output_limit(vs, vs->ioc, vs->output.offset,
                                       vs->throttle_output_offset);
         vnc_disconnect_start(vs);
         trace_vnc_client_output_limit(vs, vs->ioc, vs->output.offset,
                                       vs->throttle_output_offset);
         vnc_disconnect_start(vs);


@@ -1630,6 +1647,12 @@ void vnc_flush(VncState *vs)
     if (vs->ioc != NULL && vs->output.offset) {
         vnc_client_write_locked(vs);
     }
     if (vs->ioc != NULL && vs->output.offset) {
         vnc_client_write_locked(vs);
     }

+    if (vs->disconnecting) {
+        if (vs->ioc_tag != 0) {
+            g_source_remove(vs->ioc_tag);
+        }
+        vs->ioc_tag = 0;
+    }

     vnc_unlock_output(vs);
 }
 
     vnc_unlock_output(vs);
 }
 


@@ -1728,7 +1751,8 @@ static void reset_keys(VncState *vs)
 
 static void press_key(VncState *vs, int keysym)
 {
 
 static void press_key(VncState *vs, int keysym)
 {

-    int keycode = keysym2scancode(vs->vd->kbd_layout, keysym) & SCANCODE_KEYMASK;
+    int keycode = keysym2scancode(vs->vd->kbd_layout, keysym,
+                                  false, false, false) & SCANCODE_KEYMASK;

     qemu_input_event_send_key_number(vs->vd->dcl.con, keycode, true);
     qemu_input_event_send_key_delay(vs->vd->key_delay_ms);
     qemu_input_event_send_key_number(vs->vd->dcl.con, keycode, false);
     qemu_input_event_send_key_number(vs->vd->dcl.con, keycode, true);
     qemu_input_event_send_key_delay(vs->vd->key_delay_ms);
     qemu_input_event_send_key_number(vs->vd->dcl.con, keycode, false);


@@ -1987,6 +2011,9 @@ static const char *code2name(int keycode)
 
 static void key_event(VncState *vs, int down, uint32_t sym)
 {
 
 static void key_event(VncState *vs, int down, uint32_t sym)
 {

+    bool shift = vs->modifiers_state[0x2a] || vs->modifiers_state[0x36];
+    bool altgr = vs->modifiers_state[0xb8];
+    bool ctrl  = vs->modifiers_state[0x1d] || vs->modifiers_state[0x9d];

     int keycode;
     int lsym = sym;
 
     int keycode;
     int lsym = sym;
 


@@ -1994,7 +2021,8 @@ static void key_event(VncState *vs, int down, uint32_t sym)
         lsym = lsym - 'A' + 'a';
     }
 
         lsym = lsym - 'A' + 'a';
     }
 

-    keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF) & SCANCODE_KEYMASK;
+    keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF,
+                              shift, altgr, ctrl) & SCANCODE_KEYMASK;

     trace_vnc_key_event_map(down, sym, keycode, code2name(keycode));
     do_key_event(vs, down, keycode, sym);
 }
     trace_vnc_key_event_map(down, sym, keycode, code2name(keycode));
     do_key_event(vs, down, keycode, sym);
 }


@@ -2279,6 +2307,7 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
 {
     int i;
     uint16_t limit;
 {
     int i;
     uint16_t limit;

+    uint32_t freq;

     VncDisplay *vd = vs->vd;
 
     if (data[0] > 3) {
     VncDisplay *vd = vs->vd;
 
     if (data[0] > 3) {


@@ -2398,7 +2427,17 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
                     vnc_client_error(vs);
                     break;
                 }
                     vnc_client_error(vs);
                     break;
                 }

-                vs->as.freq = read_u32(data, 6);
+                freq = read_u32(data, 6);
+                /* No official limit for protocol, but 48khz is a sensible
+                 * upper bound for trustworthy clients, and this limit
+                 * protects calculations involving 'vs->as.freq' later.
+                 */
+                if (freq > 48000) {
+                    VNC_DEBUG("Invalid audio frequency %u > 48000", freq);
+                    vnc_client_error(vs);
+                    break;
+                }
+                vs->as.freq = freq;

                 break;
             default:
                 VNC_DEBUG("Invalid audio message %d\n", read_u8(data, 4));
                 break;
             default:
                 VNC_DEBUG("Invalid audio message %d\n", read_u8(data, 4));


@@ -2927,7 +2966,8 @@ static int vnc_refresh_server_surface(VncDisplay *vd)
             PIXMAN_FORMAT_BPP(pixman_image_get_format(vd->guest.fb));
         guest_row0 = (uint8_t *)pixman_image_get_data(vd->guest.fb);
         guest_stride = pixman_image_get_stride(vd->guest.fb);
             PIXMAN_FORMAT_BPP(pixman_image_get_format(vd->guest.fb));
         guest_row0 = (uint8_t *)pixman_image_get_data(vd->guest.fb);
         guest_stride = pixman_image_get_stride(vd->guest.fb);

-        guest_ll = pixman_image_get_width(vd->guest.fb) * (DIV_ROUND_UP(guest_bpp, 8));
+        guest_ll = pixman_image_get_width(vd->guest.fb)
+                   * DIV_ROUND_UP(guest_bpp, 8);

     }
     line_bytes = MIN(server_stride, guest_ll);
 
     }
     line_bytes = MIN(server_stride, guest_ll);
 


@@ -3031,6 +3071,7 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
     int i;
 
     trace_vnc_client_connect(vs, sioc);
     int i;
 
     trace_vnc_client_connect(vs, sioc);

+    vs->magic = VNC_MAGIC;

     vs->sioc = sioc;
     object_ref(OBJECT(vs->sioc));
     vs->ioc = QIO_CHANNEL(sioc);
     vs->sioc = sioc;
     object_ref(OBJECT(vs->sioc));
     vs->ioc = QIO_CHANNEL(sioc);


@@ -3056,8 +3097,8 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
     buffer_init(&vs->zrle.zlib,      "vnc-zrle-zlib/%p", sioc);
 
     if (skipauth) {
     buffer_init(&vs->zrle.zlib,      "vnc-zrle-zlib/%p", sioc);
 
     if (skipauth) {

-       vs->auth = VNC_AUTH_NONE;
-       vs->subauth = VNC_AUTH_INVALID;
+        vs->auth = VNC_AUTH_NONE;
+        vs->subauth = VNC_AUTH_INVALID;

     } else {
         if (websocket) {
             vs->auth = vd->ws_auth;
     } else {
         if (websocket) {
             vs->auth = vd->ws_auth;


@@ -3152,7 +3193,6 @@ static void vnc_listen_io(QIONetListener *listener,
                          isWebsock ? "vnc-ws-server" : "vnc-server");
     qio_channel_set_delay(QIO_CHANNEL(cioc), false);
     vnc_connect(vd, cioc, false, isWebsock);
                          isWebsock ? "vnc-ws-server" : "vnc-server");
     qio_channel_set_delay(QIO_CHANNEL(cioc), false);
     vnc_connect(vd, cioc, false, isWebsock);

-    object_unref(OBJECT(cioc));

 }
 
 static const DisplayChangeListenerOps dcl_ops = {
 }
 
 static const DisplayChangeListenerOps dcl_ops = {


@@ -3165,7 +3205,7 @@ static const DisplayChangeListenerOps dcl_ops = {
     .dpy_cursor_define    = vnc_dpy_cursor_define,
 };
 
     .dpy_cursor_define    = vnc_dpy_cursor_define,
 };
 

-void vnc_display_init(const char *id)
+void vnc_display_init(const char *id, Error **errp)

 {
     VncDisplay *vd;
 
 {
     VncDisplay *vd;
 


@@ -3182,13 +3222,14 @@ void vnc_display_init(const char *id)
 
     if (keyboard_layout) {
         trace_vnc_key_map_init(keyboard_layout);
 
     if (keyboard_layout) {
         trace_vnc_key_map_init(keyboard_layout);

-        vd->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
+        vd->kbd_layout = init_keyboard_layout(name2keysym,
+                                              keyboard_layout, errp);

     } else {
     } else {

-        vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
+        vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us", errp);

     }
 
     if (!vd->kbd_layout) {
     }
 
     if (!vd->kbd_layout) {

-        exit(1);
+        return;

     }
 
     vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
     }
 
     vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;


@@ -3304,10 +3345,6 @@ static QemuOptsList qemu_vnc_opts = {
         },{
             .name = "tls-creds",
             .type = QEMU_OPT_STRING,
         },{
             .name = "tls-creds",
             .type = QEMU_OPT_STRING,

-        },{
-            /* Deprecated in favour of tls-creds */
-            .name = "x509",
-            .type = QEMU_OPT_STRING,

         },{
             .name = "share",
             .type = QEMU_OPT_STRING,
         },{
             .name = "share",
             .type = QEMU_OPT_STRING,


@@ -3344,14 +3381,6 @@ static QemuOptsList qemu_vnc_opts = {
         },{
             .name = "sasl",
             .type = QEMU_OPT_BOOL,
         },{
             .name = "sasl",
             .type = QEMU_OPT_BOOL,

-        },{
-            /* Deprecated in favour of tls-creds */
-            .name = "tls",
-            .type = QEMU_OPT_BOOL,
-        },{
-            /* Deprecated in favour of tls-creds */
-            .name = "x509verify",
-            .type = QEMU_OPT_STRING,

         },{
             .name = "acl",
             .type = QEMU_OPT_BOOL,
         },{
             .name = "acl",
             .type = QEMU_OPT_BOOL,


@@ -3479,51 +3508,6 @@ vnc_display_setup_auth(int *auth,
 }
 
 
 }
 
 

-/*
- * Handle back compat with old CLI syntax by creating some
- * suitable QCryptoTLSCreds objects
- */
-static QCryptoTLSCreds *
-vnc_display_create_creds(bool x509,
-                         bool x509verify,
-                         const char *dir,
-                         const char *id,
-                         Error **errp)
-{
-    gchar *credsid = g_strdup_printf("tlsvnc%s", id);
-    Object *parent = object_get_objects_root();
-    Object *creds;
-    Error *err = NULL;
-
-    if (x509) {
-        creds = object_new_with_props(TYPE_QCRYPTO_TLS_CREDS_X509,
-                                      parent,
-                                      credsid,
-                                      &err,
-                                      "endpoint", "server",
-                                      "dir", dir,
-                                      "verify-peer", x509verify ? "yes" : "no",
-                                      NULL);
-    } else {
-        creds = object_new_with_props(TYPE_QCRYPTO_TLS_CREDS_ANON,
-                                      parent,
-                                      credsid,
-                                      &err,
-                                      "endpoint", "server",
-                                      NULL);
-    }
-
-    g_free(credsid);
-
-    if (err) {
-        error_propagate(errp, err);
-        return NULL;
-    }
-
-    return QCRYPTO_TLS_CREDS(creds);
-}
-
-

 static int vnc_display_get_address(const char *addrstr,
                                    bool websocket,
                                    bool reverse,
 static int vnc_display_get_address(const char *addrstr,
                                    bool websocket,
                                    bool reverse,


@@ -3838,9 +3822,6 @@ void vnc_display_open(const char *id, Error **errp)
     bool reverse = false;
     const char *credid;
     bool sasl = false;
     bool reverse = false;
     const char *credid;
     bool sasl = false;

-#ifdef CONFIG_VNC_SASL
-    int saslErr;
-#endif

     int acl = 0;
     int lock_key_sync = 1;
     int key_delay_ms;
     int acl = 0;
     int lock_key_sync = 1;
     int key_delay_ms;


@@ -3890,15 +3871,6 @@ void vnc_display_open(const char *id, Error **errp)
     credid = qemu_opt_get(opts, "tls-creds");
     if (credid) {
         Object *creds;
     credid = qemu_opt_get(opts, "tls-creds");
     if (credid) {
         Object *creds;

-        if (qemu_opt_get(opts, "tls") ||
-            qemu_opt_get(opts, "x509") ||
-            qemu_opt_get(opts, "x509verify")) {
-            error_setg(errp,
-                       "'tls-creds' parameter is mutually exclusive with "
-                       "'tls', 'x509' and 'x509verify' parameters");
-            goto fail;
-        }
-

         creds = object_resolve_path_component(
             object_get_objects_root(), credid);
         if (!creds) {
         creds = object_resolve_path_component(
             object_get_objects_root(), credid);
         if (!creds) {


@@ -3921,31 +3893,6 @@ void vnc_display_open(const char *id, Error **errp)
                        "Expecting TLS credentials with a server endpoint");
             goto fail;
         }
                        "Expecting TLS credentials with a server endpoint");
             goto fail;
         }

-    } else {
-        const char *path;
-        bool tls = false, x509 = false, x509verify = false;
-        tls  = qemu_opt_get_bool(opts, "tls", false);
-        if (tls) {
-            path = qemu_opt_get(opts, "x509");
-
-            if (path) {
-                x509 = true;
-            } else {
-                path = qemu_opt_get(opts, "x509verify");
-                if (path) {
-                    x509 = true;
-                    x509verify = true;
-                }
-            }
-            vd->tlscreds = vnc_display_create_creds(x509,
-                                                    x509verify,
-                                                    path,
-                                                    vd->id,
-                                                    errp);
-            if (!vd->tlscreds) {
-                goto fail;
-            }
-        }

     }
     acl = qemu_opt_get_bool(opts, "acl", false);
 
     }
     acl = qemu_opt_get_bool(opts, "acl", false);
 


@@ -4014,10 +3961,14 @@ void vnc_display_open(const char *id, Error **errp)
     trace_vnc_auth_init(vd, 1, vd->ws_auth, vd->ws_subauth);
 
 #ifdef CONFIG_VNC_SASL
     trace_vnc_auth_init(vd, 1, vd->ws_auth, vd->ws_subauth);
 
 #ifdef CONFIG_VNC_SASL

-    if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
-        error_setg(errp, "Failed to initialize SASL auth: %s",
-                   sasl_errstring(saslErr, NULL, NULL));
-        goto fail;
+    if (sasl) {
+        int saslErr = sasl_server_init(NULL, "qemu");
+
+        if (saslErr != SASL_OK) {
+            error_setg(errp, "Failed to initialize SASL auth: %s",
+                       sasl_errstring(saslErr, NULL, NULL));
+            goto fail;
+        }

     }
 #endif
     vd->lock_key_sync = lock_key_sync;
     }
 #endif
     vd->lock_key_sync = lock_key_sync;


@@ -4129,11 +4080,15 @@ int vnc_init_func(void *opaque, QemuOpts *opts, Error **errp)
     char *id = (char *)qemu_opts_id(opts);
 
     assert(id);
     char *id = (char *)qemu_opts_id(opts);
 
     assert(id);

-    vnc_display_init(id);
+    vnc_display_init(id, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        return -1;
+    }

     vnc_display_open(id, &local_err);
     if (local_err != NULL) {
     vnc_display_open(id, &local_err);
     if (local_err != NULL) {

-        error_reportf_err(local_err, "Failed to start VNC server: ");
-        exit(1);
+        error_propagate(errp, local_err);
+        return -1;

     }
     return 0;
 }
     }
     return 0;
 }