pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-01-05 22:21:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test-stream-device: Factor out VMC emulation

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

Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
Acked-by: Victor Toso <victortoso@redhat.com>
This commit is contained in:
Frediano Ziglio 2019-10-07 09:57:58 +01:00
parent 07d9328f89
commit b4e508880a
5 changed files with 236 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/tests/Makefile.am
View File

@ -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 = \

2
server/tests/meson.build
View File

@ -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 = []

224
server/tests/test-stream-device.c
View File

@ -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

121
server/tests/vmc-emu.c Normal file
View File

@ -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;
}

48
server/tests/vmc-emu.h Normal file
View File

@ -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);