[Spice-devel] [PATCH spice-server v3 3/5] test-stream-device: Factor out VMC emulation

Frediano Ziglio fziglio at redhat.com
Wed Oct 9 09:23:00 UTC 2019


Allows to reuse code for emulating a character device.
It will be used for Smardcard test.

Signed-off-by: Frediano Ziglio <fziglio at redhat.com>
Acked-by: Victor Toso <victortoso at redhat.com>
---
 server/tests/Makefile.am          |   2 +
 server/tests/meson.build          |   2 +
 server/tests/test-stream-device.c | 224 +++++++++---------------------
 server/tests/vmc-emu.c            | 121 ++++++++++++++++
 server/tests/vmc-emu.h            |  48 +++++++
 5 files changed, 236 insertions(+), 161 deletions(-)
 create mode 100644 server/tests/vmc-emu.c
 create mode 100644 server/tests/vmc-emu.h

diff --git a/server/tests/Makefile.am b/server/tests/Makefile.am
index 1e62557a8..982508510 100644
--- a/server/tests/Makefile.am
+++ b/server/tests/Makefile.am
@@ -37,6 +37,8 @@ libtest_a_SOURCES =				\
 	test-glib-compat.h			\
 	win-alarm.c				\
 	win-alarm.h				\
+	vmc-emu.c				\
+	vmc-emu.h				\
 	$(NULL)
 
 LDADD =								\
diff --git a/server/tests/meson.build b/server/tests/meson.build
index c9377f1eb..33472f14e 100644
--- a/server/tests/meson.build
+++ b/server/tests/meson.build
@@ -13,6 +13,8 @@ test_lib_sources = [
   'test-glib-compat.h',
   'win-alarm.c',
   'win-alarm.h',
+  'vmc-emu.c',
+  'vmc-emu.h',
 ]
 
 test_libs = []
diff --git a/server/tests/test-stream-device.c b/server/tests/test-stream-device.c
index a5e85f118..abf66f043 100644
--- a/server/tests/test-stream-device.c
+++ b/server/tests/test-stream-device.c
@@ -34,84 +34,9 @@
 #include "stream-channel.h"
 #include "reds.h"
 #include "win-alarm.h"
+#include "vmc-emu.h"
 
-static SpiceCharDeviceInstance vmc_instance;
-
-// device buffer to read from
-static uint8_t message[2048];
-// position to read from
-static unsigned pos;
-// array of limits when the read should return
-// the array is defined as [message_sizes_curr, message_sizes_end)
-// then the size is reach we move on next one till exausted
-static unsigned message_sizes[16];
-static unsigned *message_sizes_end, *message_sizes_curr;
-static bool device_enabled = false;
-
-static unsigned vmc_write_pos;
-static uint8_t vmc_write_buf[2048];
-
-// handle writes to the device
-static int vmc_write(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
-                     SPICE_GNUC_UNUSED const uint8_t *buf,
-                     int len)
-{
-    // just copy into the buffer
-    unsigned copy = MIN(sizeof(vmc_write_buf) - vmc_write_pos, len);
-    memcpy(vmc_write_buf+vmc_write_pos, buf, copy);
-    vmc_write_pos += copy;
-    return len;
-}
-
-static int vmc_read(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
-                    uint8_t *buf,
-                    int len)
-{
-    int ret;
-
-    if (pos >= *message_sizes_curr && message_sizes_curr < message_sizes_end) {
-        ++message_sizes_curr;
-    }
-    if (message_sizes_curr >= message_sizes_end || pos >= *message_sizes_curr) {
-        return 0;
-    }
-    ret = MIN(*message_sizes_curr - pos, len);
-    memcpy(buf, &message[pos], ret);
-    pos += ret;
-    // kick off next message read
-    // currently Qemu kicks the device so we need to do it manually
-    // here. If not all data are read, the device goes into blocking
-    // state and we get the wake only when we read from the device
-    // again
-    if (pos >= *message_sizes_curr) {
-        spice_server_char_device_wakeup(&vmc_instance);
-    }
-    return ret;
-}
-
-static void vmc_state(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
-                      SPICE_GNUC_UNUSED int connected)
-{
-    device_enabled = !!connected;
-}
-
-static SpiceCharDeviceInterface vmc_interface = {
-    .base = {
-        .type          = SPICE_INTERFACE_CHAR_DEVICE,
-        .description   = "test spice virtual channel char device",
-        .major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
-        .minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
-    },
-    .state              = vmc_state,
-    .write              = vmc_write,
-    .read               = vmc_read,
-};
-
-// this specifically creates a stream device
-static SpiceCharDeviceInstance vmc_instance = {
-    .subtype = "port",
-    .portname = "org.spice-space.stream.0",
-};
+static VmcEmu *vmc;
 
 static uint8_t *add_stream_hdr(uint8_t *p, StreamMsgType type, uint32_t size)
 {
@@ -145,18 +70,18 @@ discard_server_capabilities(void)
 {
     StreamDevHeader hdr;
 
-    if (vmc_write_pos == 0) {
+    if (vmc->write_pos == 0) {
         return;
     }
-    g_assert(vmc_write_pos >= sizeof(hdr));
+    g_assert(vmc->write_pos >= sizeof(hdr));
 
-    memcpy(&hdr, vmc_write_buf, sizeof(hdr));
+    memcpy(&hdr, vmc->write_buf, sizeof(hdr));
     hdr.type = GUINT16_FROM_LE(hdr.type);
     hdr.size = GUINT32_FROM_LE(hdr.size);
     if (hdr.type == STREAM_TYPE_CAPABILITIES) {
-        g_assert_cmpint(hdr.size, <=, vmc_write_pos - sizeof(hdr));
-        vmc_write_pos -= hdr.size + sizeof(hdr);
-        memmove(vmc_write_buf, vmc_write_buf + hdr.size + sizeof(hdr), vmc_write_pos);
+        g_assert_cmpint(hdr.size, <=, vmc->write_pos - sizeof(hdr));
+        vmc->write_pos -= hdr.size + sizeof(hdr);
+        memmove(vmc->write_buf, vmc->write_buf + hdr.size + sizeof(hdr), vmc->write_pos);
     }
 }
 
@@ -168,12 +93,12 @@ check_vmc_error_message(void)
 
     discard_server_capabilities();
 
-    g_assert_cmpint(vmc_write_pos, >= ,sizeof(hdr));
+    g_assert_cmpint(vmc->write_pos, >= ,sizeof(hdr));
 
-    memcpy(&hdr, vmc_write_buf, sizeof(hdr));
+    memcpy(&hdr, vmc->write_buf, sizeof(hdr));
     g_assert_cmpint(hdr.protocol_version, ==, STREAM_DEVICE_PROTOCOL);
     g_assert_cmpint(GUINT16_FROM_LE(hdr.type), ==, STREAM_TYPE_NOTIFY_ERROR);
-    g_assert_cmpint(GUINT32_FROM_LE(hdr.size), <=, vmc_write_pos - sizeof(hdr));
+    g_assert_cmpint(GUINT32_FROM_LE(hdr.size), <=, vmc->write_pos - sizeof(hdr));
 }
 
 static int num_send_data_calls = 0;
@@ -249,15 +174,13 @@ static void test_stream_device_setup(TestFixture *fixture, gconstpointer user_da
 {
     g_assert_null(core);
     g_assert_null(test);
+    g_assert_null(vmc);
     core = basic_event_loop_init();
     g_assert_nonnull(core);
     test = test_new(core);
     g_assert_nonnull(test);
-
-    pos = 0;
-    vmc_write_pos = 0;
-    message_sizes_curr = message_sizes;
-    message_sizes_end = message_sizes;
+    vmc = vmc_emu_new("port", "org.spice-space.stream.0");
+    g_assert_nonnull(vmc);
 
     num_send_data_calls = 0;
     send_data_bytes = 0;
@@ -268,6 +191,8 @@ static void test_stream_device_teardown(TestFixture *fixture, gconstpointer user
     g_assert_nonnull(core);
     g_assert_nonnull(test);
 
+    vmc_emu_destroy(vmc);
+    vmc = NULL;
     test_destroy(test);
     test = NULL;
     basic_event_loop_destroy();
@@ -276,122 +201,109 @@ static void test_stream_device_teardown(TestFixture *fixture, gconstpointer user
 
 static void test_kick(void)
 {
-    vmc_instance.base.sif = &vmc_interface.base;
-    spice_server_add_interface(test->server, &vmc_instance.base);
+    spice_server_add_interface(test->server, &vmc->instance.base);
 
     // we need to open the device and kick the start
     // the alarm is to prevent the program from getting stuck
     alarm(5);
-    spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_OPENED);
-    spice_server_char_device_wakeup(&vmc_instance);
+    spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_OPENED);
+    spice_server_char_device_wakeup(&vmc->instance);
     alarm(0);
 }
 
 static void test_stream_device(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
-
     for (int test_num=0; test_num < 2; ++test_num) {
-        pos = 0;
-        vmc_write_pos = 0;
-        message_sizes_curr = message_sizes;
-        message_sizes_end = message_sizes;
+        vmc_emu_reset(vmc);
+        uint8_t *p = vmc->message;
 
         // add some messages into device buffer
         // here we are testing the device is reading at least two
         // consecutive format messages
         // first message part has 2 extra bytes to check for header split
         p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
-        *message_sizes_end = p - message + 2;
-        ++message_sizes_end;
+        vmc_emu_add_read_till(vmc, p + 2);
 
         p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_VP9);
 
         // this split the second format in half
-        *message_sizes_end = p - message - 4;
-        ++message_sizes_end;
+        vmc_emu_add_read_till(vmc, p - 4);
 
-        *message_sizes_end = p - message;
-        ++message_sizes_end;
+        vmc_emu_add_read_till(vmc, p);
 
         // add a message to stop data to be read
         p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
-        *message_sizes_end = p - message;
-        ++message_sizes_end;
+        vmc_emu_add_read_till(vmc, p);
 
         // this message should not be read
         p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
-        *message_sizes_end = p - message;
-        ++message_sizes_end;
+        vmc_emu_add_read_till(vmc, p);
 
-        vmc_instance.base.sif = &vmc_interface.base;
-        spice_server_add_interface(test->server, &vmc_instance.base);
+        spice_server_add_interface(test->server, &vmc->instance.base);
 
         // device should not have read data before we open it
-        spice_server_char_device_wakeup(&vmc_instance);
-        g_assert_cmpint(pos, ==, 0);
+        spice_server_char_device_wakeup(&vmc->instance);
+        g_assert_cmpint(vmc->pos, ==, 0);
 
         g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: Invalid message type");
 
         // we need to open the device and kick the start
-        spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_OPENED);
-        spice_server_char_device_wakeup(&vmc_instance);
-        spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_CLOSED);
+        spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_OPENED);
+        spice_server_char_device_wakeup(&vmc->instance);
+        spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_CLOSED);
 
         // make sure first 3 parts are read completely
-        g_assert(message_sizes_curr - message_sizes >= 3);
+        g_assert(vmc->message_sizes_curr - vmc->message_sizes >= 3);
         // make sure the device readed all or that device was
         // disabled, we need this to make sure that device will be in
         // sync when opened again
-        g_assert(message_sizes_curr - message_sizes == 5 || !device_enabled);
+        g_assert(vmc->message_sizes_curr - vmc->message_sizes == 5 || !vmc->device_enabled);
 
         check_vmc_error_message();
-        spice_server_remove_interface(&vmc_instance.base);
+        spice_server_remove_interface(&vmc->instance.base);
     }
 }
 
 // check if sending a partial message causes issues
 static void test_stream_device_unfinished(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // this long and not finished message should not cause an infinite loop
     p = add_stream_hdr(p, STREAM_TYPE_DATA, 100000);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     test_kick();
 
     // we should have read all data
-    g_assert(message_sizes_curr - message_sizes == 1);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
 
     // we should have no data from the device
     discard_server_capabilities();
-    g_assert_cmpint(vmc_write_pos, ==, 0);
+    g_assert_cmpint(vmc->write_pos, ==, 0);
 }
 
 // check if sending multiple messages cause stall
 static void test_stream_device_multiple(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // add some messages into device buffer
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     test_kick();
 
     // we should have read all data
-    g_assert(message_sizes_curr - message_sizes == 1);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
 }
 
 // check if data message consume even following message
 static void test_stream_device_format_after_data(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // add some messages into device buffer
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
@@ -399,15 +311,14 @@ static void test_stream_device_format_after_data(TestFixture *fixture, gconstpoi
     memcpy(p, "hello", 5);
     p += 5;
     p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: Invalid message type");
 
     test_kick();
 
     // we should read all data
-    g_assert(message_sizes_curr - message_sizes == 1);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
 
     // we should have an error back
     check_vmc_error_message();
@@ -417,46 +328,42 @@ static void test_stream_device_format_after_data(TestFixture *fixture, gconstpoi
 static void test_stream_device_empty(TestFixture *fixture, gconstpointer user_data)
 {
     const StreamMsgType msg_type = (StreamMsgType) GPOINTER_TO_INT(user_data);
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // add some messages into device buffer
     p = add_stream_hdr(p, msg_type, 0);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     test_kick();
 
     // we should read all data
-    g_assert(message_sizes_curr - message_sizes == 3);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 3);
 
     // we should have no data from the device
     discard_server_capabilities();
-    g_assert_cmpint(vmc_write_pos, ==, 0);
+    g_assert_cmpint(vmc->write_pos, ==, 0);
 }
 
 // check that server refuse huge data messages
 static void test_stream_device_huge_data(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // add some messages into device buffer
     p = add_stream_hdr(p, STREAM_TYPE_DATA, 33 * 1024 * 1024);
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: STREAM_DATA too large");
 
     test_kick();
 
     // we should read all data
-    g_assert(message_sizes_curr - message_sizes == 1);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
 
     // we should have an error back
     check_vmc_error_message();
@@ -465,7 +372,7 @@ static void test_stream_device_huge_data(TestFixture *fixture, gconstpointer use
 // check that server send all message
 static void test_stream_device_data_message(TestFixture *fixture, gconstpointer user_data)
 {
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
 
     // add some messages into device buffer
     p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
@@ -473,23 +380,19 @@ static void test_stream_device_data_message(TestFixture *fixture, gconstpointer
     for (int i = 0; i < 1017; ++i, ++p) {
         *p = (uint8_t) (i * 123 + 57);
     }
-    *message_sizes_end = 51;
-    ++message_sizes_end;
-    *message_sizes_end = 123;
-    ++message_sizes_end;
-    *message_sizes_end = 534;
-    ++message_sizes_end;
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, vmc->message + 51);
+    vmc_emu_add_read_till(vmc, vmc->message + 123);
+    vmc_emu_add_read_till(vmc, vmc->message + 534);
+    vmc_emu_add_read_till(vmc, p);
 
     test_kick();
 
     // we should read all data
-    g_assert(message_sizes_curr - message_sizes == 4);
+    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 4);
 
     // we should have no data from the device
     discard_server_capabilities();
-    g_assert_cmpint(vmc_write_pos, ==, 0);
+    g_assert_cmpint(vmc->write_pos, ==, 0);
 
     // make sure data were collapsed in a single message
     g_assert_cmpint(num_send_data_calls, ==, 1);
@@ -512,15 +415,14 @@ static void test_display_info(TestFixture *fixture, gconstpointer user_data)
         .device_display_id = GUINT32_TO_LE(0x0a0b0c0d),
         .device_address_len = GUINT32_TO_LE(sizeof(address)),
     };
-    uint8_t *p = message;
+    uint8_t *p = vmc->message;
     p = add_stream_hdr(p, STREAM_TYPE_DEVICE_DISPLAY_INFO, sizeof(info) + sizeof(address));
     memcpy(p, &info, sizeof(info));
     p += sizeof(info);
     strcpy((char*)p, address);
     p += sizeof(address);
 
-    *message_sizes_end = p - message;
-    ++message_sizes_end;
+    vmc_emu_add_read_till(vmc, p);
 
     // parse the simulated display info message from the stream device so the server now has display
     // info for the mock stream device
diff --git a/server/tests/vmc-emu.c b/server/tests/vmc-emu.c
new file mode 100644
index 000000000..418a02139
--- /dev/null
+++ b/server/tests/vmc-emu.c
@@ -0,0 +1,121 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+   Copyright (C) 2019 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <config.h>
+#include <glib.h>
+
+#include "vmc-emu.h"
+
+// handle writes to the device
+static int vmc_write(SpiceCharDeviceInstance *sin,
+                     const uint8_t *buf, int len)
+{
+    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
+
+    // just copy into the buffer
+    unsigned copy = MIN(sizeof(vmc->write_buf) - vmc->write_pos, len);
+    memcpy(vmc->write_buf+vmc->write_pos, buf, copy);
+    vmc->write_pos += copy;
+    return len;
+}
+
+static int vmc_read(SpiceCharDeviceInstance *sin,
+                    uint8_t *buf, int len)
+{
+    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
+    int ret;
+
+    if (vmc->pos >= *vmc->message_sizes_curr && vmc->message_sizes_curr < vmc->message_sizes_end) {
+        ++vmc->message_sizes_curr;
+    }
+    if (vmc->message_sizes_curr >= vmc->message_sizes_end || vmc->pos >= *vmc->message_sizes_curr) {
+        return 0;
+    }
+    ret = MIN(*vmc->message_sizes_curr - vmc->pos, len);
+    memcpy(buf, &vmc->message[vmc->pos], ret);
+    vmc->pos += ret;
+    // kick off next message read
+    // currently Qemu kicks the device so we need to do it manually
+    // here. If not all data are read, the device goes into blocking
+    // state and we get the wake only when we read from the device
+    // again
+    if (vmc->pos >= *vmc->message_sizes_curr) {
+        spice_server_char_device_wakeup(&vmc->instance);
+    }
+    return ret;
+}
+
+static void vmc_state(SpiceCharDeviceInstance *sin,
+                      int connected)
+{
+    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
+    vmc->device_enabled = !!connected;
+}
+
+static const SpiceCharDeviceInterface vmc_interface = {
+    .base = {
+        .type          = SPICE_INTERFACE_CHAR_DEVICE,
+        .description   = "test spice virtual channel char device",
+        .major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
+        .minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
+    },
+    .state              = vmc_state,
+    .write              = vmc_write,
+    .read               = vmc_read,
+};
+
+VmcEmu *vmc_emu_new(const char *subtype, const char *portname)
+{
+    VmcEmu *vmc = g_new0(VmcEmu, 1);
+    vmc->vmc_interface = vmc_interface;
+    vmc->instance.base.sif = &vmc->vmc_interface.base;
+    vmc->instance.subtype = g_strdup(subtype);
+    if (portname) {
+        vmc->instance.portname = g_strdup(portname);
+    }
+    vmc_emu_reset(vmc);
+    return vmc;
+}
+
+void vmc_emu_destroy(VmcEmu *vmc)
+{
+    g_free((char *) vmc->instance.portname);
+    g_free((char *) vmc->instance.subtype);
+    g_free(vmc);
+}
+
+void vmc_emu_reset(VmcEmu *vmc)
+{
+    vmc->pos = 0;
+    vmc->write_pos = 0;
+    vmc->message_sizes_curr = vmc->message_sizes;
+    vmc->message_sizes_end = vmc->message_sizes;
+}
+
+void vmc_emu_add_read_till(VmcEmu *vmc, uint8_t *end)
+{
+    g_assert(vmc->message_sizes_end - vmc->message_sizes < G_N_ELEMENTS(vmc->message_sizes));
+    g_assert(end >= vmc->message);
+    g_assert(end - vmc->message <= G_N_ELEMENTS(vmc->message));
+    unsigned prev_size =
+        vmc->message_sizes_end > vmc->message_sizes ? vmc->message_sizes_end[-1] : 0;
+    unsigned size = end - vmc->message;
+    g_assert(size >= prev_size);
+    *vmc->message_sizes_end = size;
+    ++vmc->message_sizes_end;
+}
diff --git a/server/tests/vmc-emu.h b/server/tests/vmc-emu.h
new file mode 100644
index 000000000..7c26938eb
--- /dev/null
+++ b/server/tests/vmc-emu.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+   Copyright (C) 2019 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "char-device.h"
+
+typedef struct VmcEmu VmcEmu;
+
+struct VmcEmu {
+    SpiceCharDeviceInterface vmc_interface;
+    SpiceCharDeviceInstance instance;
+
+    // device buffer to read from
+    uint8_t message[2048];
+    // position to read from
+    unsigned pos;
+
+    // array of limits when the read should return
+    // the array is defined as [message_sizes_curr, message_sizes_end)
+    // then the size is reach we move on next one till exausted
+    unsigned message_sizes[16];
+    unsigned *message_sizes_end, *message_sizes_curr;
+
+    bool device_enabled;
+
+    unsigned write_pos;
+    uint8_t write_buf[2048];
+};
+
+VmcEmu *vmc_emu_new(const char *subtype, const char *portname);
+void vmc_emu_destroy(VmcEmu *vmc);
+void vmc_emu_reset(VmcEmu *vmc);
+void vmc_emu_add_read_till(VmcEmu *vmc, uint8_t *end);
-- 
2.21.0



More information about the Spice-devel mailing list