On Mon, Oct 07, 2019 at 11:38:59AM +0100, Frediano Ziglio wrote:
> Allows to reuse code for emulating a character device.
> It will be used for Smardcard test.
>
> Signed-off-by: Frediano Ziglio <fziglio@xxxxxxxxxx>
> ---
> 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 1e62557a..98250851 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 c9377f1e..33472f14 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 f5698c7d..613caed3 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;
> @@ -246,15 +171,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;
> @@ -265,6 +188,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();
> @@ -273,122 +198,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);
> @@ -396,15 +308,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();
> @@ -414,46 +325,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();
> @@ -462,7 +369,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);
> @@ -470,23 +377,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);
> @@ -509,15 +412,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 00000000..ddac5269
> --- /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->interface = vmc_interface;
> + vmc->instance.base.sif = &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));
I'd move the unsigned size here and change both asserts to use
it, that is:
unsigned size = end - vmc->message;
g_assert(size >= 0);
g_assert(size <= G_N_ELEMENTS(vmc->message));
This is my only nitpick for this patch, feel free to ignore if
you want
Acked-by: Victor Toso <victortoso@xxxxxxxxxx>
> + 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;
Forgot how long since I saw a negative index in C!
> + 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 00000000..6fcea69d
> --- /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 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
>
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
Attachment:
signature.asc
Description: PGP signature
_______________________________________________ Spice-devel mailing list Spice-devel@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/spice-devel