pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2025-12-30 09:46:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

server/tests: add test_display_no_ssl

Browse Source 
updates taken from spice vga mode updates, i.e. non cacheable, glz compressed
(depends on whatever settings you apply to the server) opaque draw operations.
 + completed the SpiceCoreInterface implementation (timers)

v1->v2:
 removed test_util.c (Hans)
 replaced mallocz with calloc (Hans)
This commit is contained in:
Alon Levy 2010-11-10 19:36:47 +02:00
parent 74b39efd6e
commit 9002d3f005
4 changed files with 589 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
server/tests/Makefile.am
View File

@ -1,14 +1,19 @@
NULL =
INCLUDES = \
-I.. \
$(PROTOCOL_CFLAGS) \
$(SPICE_NONPKGCONFIG_CFLAGS) \
INCLUDES = \
-I.. \
-I../../common \
$(PROTOCOL_CFLAGS) \
$(SPICE_NONPKGCONFIG_CFLAGS) \
$(NULL)
LDFLAGS = -L../.libs -lspice-server
noinst_PROGRAMS = test_just_sockets_no_ssl test_empty_success test_fail_on_null_core_interface
noinst_PROGRAMS = test_just_sockets_no_ssl test_empty_success test_fail_on_null_core_interface test_display_no_ssl
test_display_no_ssl_SOURCES = test_display_no_ssl.c basic_event_loop.c
test_display_no_ssl_LDFLAGS = $(LDFLAGS)
test_just_sockets_no_ssl_SOURCES = test_just_sockets_no_ssl.c basic_event_loop.c basic_event_loop.h

322
server/tests/basic_event_loop.c
View File

@ -1,84 +1,222 @@
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include "test_util.h"
#include "basic_event_loop.h"
int debug = 0;
#define DPRINTF(x, format, ...) { \
if (x <= debug) { \
printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
} \
}
/* From ring.h */
typedef struct Ring RingItem;
typedef struct Ring {
RingItem *prev;
RingItem *next;
} Ring;
static inline void ring_init(Ring *ring)
{
ring->next = ring->prev = ring;
}
static inline void ring_item_init(RingItem *item)
{
item->next = item->prev = NULL;
}
static inline int ring_item_is_linked(RingItem *item)
{
return !!item->next;
}
static inline int ring_is_empty(Ring *ring)
{
ASSERT(ring->next != NULL && ring->prev != NULL);
return ring == ring->next;
}
static inline void ring_add(Ring *ring, RingItem *item)
{
ASSERT(ring->next != NULL && ring->prev != NULL);
ASSERT(item->next == NULL && item->prev == NULL);
item->next = ring->next;
item->prev = ring;
ring->next = item->next->prev = item;
}
static inline void __ring_remove(RingItem *item)
{
item->next->prev = item->prev;
item->prev->next = item->next;
item->prev = item->next = 0;
}
static inline void ring_remove(RingItem *item)
{
ASSERT(item->next != NULL && item->prev != NULL);
ASSERT(item->next != item);
__ring_remove(item);
}
static inline RingItem *ring_get_head(Ring *ring)
{
RingItem *ret;
ASSERT(ring->next != NULL && ring->prev != NULL);
if (ring_is_empty(ring)) {
return NULL;
}
ret = ring->next;
return ret;
}
static inline RingItem *ring_get_tail(Ring *ring)
{
RingItem *ret;
ASSERT(ring->next != NULL && ring->prev != NULL);
if (ring_is_empty(ring)) {
return NULL;
}
ret = ring->prev;
return ret;
}
static inline RingItem *ring_next(Ring *ring, RingItem *pos)
{
RingItem *ret;
ASSERT(ring->next != NULL && ring->prev != NULL);
ASSERT(pos);
ASSERT(pos->next != NULL && pos->prev != NULL);
ret = pos->next;
return (ret == ring) ? NULL : ret;
}
static inline RingItem *ring_prev(Ring *ring, RingItem *pos)
{
RingItem *ret;
ASSERT(ring->next != NULL && ring->prev != NULL);
ASSERT(pos);
ASSERT(pos->next != NULL && pos->prev != NULL);
ret = pos->prev;
return (ret == ring) ? NULL : ret;
}
#define RING_FOREACH_SAFE(var, next, ring) \
for ((var) = ring_get_head(ring), \
(next) = (var) ? ring_next(ring, (var)) : NULL; \
(var); \
(var) = (next), \
(next) = (var) ? ring_next(ring, (var)) : NULL)
/**/
#define NOT_IMPLEMENTED printf("%s not implemented\n", __func__);
static SpiceCoreInterface core;
typedef struct SpiceTimer {
RingItem link;
SpiceTimerFunc func;
struct timeval tv_start;
int ms;
void *opaque;
} Timer;
Ring timers;
static SpiceTimer* timer_add(SpiceTimerFunc func, void *opaque)
{
NOT_IMPLEMENTED
SpiceTimer *timer = calloc(sizeof(SpiceTimer), 1);
timer->func = func;
timer->opaque = opaque;
ring_add(&timers, &timer->link);
return timer;
}
static void add_ms_to_timeval(struct timeval *tv, int ms)
{
tv->tv_usec += 1000 * ms;
while (tv->tv_usec >= 1000000) {
tv->tv_sec++;
tv->tv_usec -= 1000000;
}
}
static void timer_start(SpiceTimer *timer, uint32_t ms)
{
NOT_IMPLEMENTED
gettimeofday(&timer->tv_start, NULL);
timer->ms = ms;
// already add ms to timer value
add_ms_to_timeval(&timer->tv_start, ms);
ASSERT(timer->ms);
}
static void timer_cancel(SpiceTimer *timer)
{
NOT_IMPLEMENTED
timer->ms = 0;
}
static void timer_remove(SpiceTimer *timer)
{
NOT_IMPLEMENTED
ring_remove(&timer->link);
}
struct SpiceWatch {
int id;
};
typedef struct Watch {
SpiceWatch id;
RingItem link;
int fd;
int event_mask;
SpiceWatchFunc func;
void *opaque;
} Watch;
int remove;
};
Ring watches;
Watch watches[100];
int watch_count = 0;
int next_id = 1;
static SpiceWatch *watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
{
watches[watch_count].fd = fd;
watches[watch_count].event_mask = event_mask;
watches[watch_count].func = func;
watches[watch_count].opaque = opaque;
watches[watch_count].id.id = next_id++;
return &watches[watch_count++].id;
SpiceWatch *watch = malloc(sizeof(SpiceWatch));
DPRINTF(0, "adding %p, fd=%d at %d", watch,
fd, watch_count);
watch->fd = fd;
watch->event_mask = event_mask;
watch->func = func;
watch->opaque = opaque;
watch->remove = FALSE;
ring_item_init(&watch->link);
ring_add(&watches, &watch->link);
watch_count++;
return watch;
}
static void watch_update_mask(SpiceWatch *watch, int event_mask)
{
int i;
Watch *my_watch;
for (i = 0 ; i < watch_count; ++i) {
if (watches[i].id.id == watch->id) {
my_watch = &watches[i];
if (my_watch->event_mask != event_mask) {
my_watch->event_mask = event_mask;
}
return;
}
}
DPRINTF(0, "fd %d to %d", watch->fd, event_mask);
watch->event_mask = event_mask;
}
static void watch_remove(SpiceWatch *watch)
{
int i;
for (i = 0 ; i < watch_count ; ++i) {
if (watches[i].id.id == watch->id) {
watches[i] = watches[--watch_count];
return;
}
}
DPRINTF(0, "remove %p (fd %d)", watch, watch->fd);
ring_remove(&watch->link);
watch->remove = TRUE;
watch_count--;
}
static void channel_event(int event, SpiceChannelEventInfo *info)
@ -86,18 +224,86 @@ static void channel_event(int event, SpiceChannelEventInfo *info)
NOT_IMPLEMENTED
}
SpiceTimer *get_next_timer(void)
{
SpiceTimer *next, *min;
if (ring_is_empty(&timers)) {
return NULL;
}
min = next = (SpiceTimer*)ring_get_head(&timers);
while ((next=(SpiceTimer*)ring_next(&timers, &next->link)) != NULL) {
if (next->ms &&
(next->tv_start.tv_sec < min->tv_start.tv_sec ||
(next->tv_start.tv_sec == min->tv_start.tv_sec &&
next->tv_start.tv_usec < min->tv_start.tv_usec))) {
min = next;
}
}
return min;
}
struct timeval now;
void tv_b_minus_a_return_le_zero(struct timeval *a, struct timeval *b, struct timeval *dest)
{
dest->tv_usec = b->tv_usec - a->tv_usec;
dest->tv_sec = b->tv_sec - a->tv_sec;
while (dest->tv_usec < 0) {
dest->tv_usec += 1000000;
dest->tv_sec--;
}
if (dest->tv_sec < 0) {
dest->tv_sec = 0;
dest->tv_usec = 0;
}
}
void calc_next_timeout(SpiceTimer *next, struct timeval *timeout)
{
gettimeofday(&now, NULL);
tv_b_minus_a_return_le_zero(&now, &next->tv_start, timeout);
}
void timeout_timers()
{
SpiceTimer *next;
struct timeval left;
int count = 0;
next = (SpiceTimer*)ring_get_head(&timers);
while (next != NULL) {
tv_b_minus_a_return_le_zero(&now, &next->tv_start, &left);
if (next->ms && left.tv_usec == 0 && left.tv_sec == 0) {
count++;
DPRINTF(1, "calling timer");
next->func(next->opaque);
}
next = (SpiceTimer*)ring_next(&timers, &next->link);
}
DPRINTF(1, "called %d timers", count);
}
void basic_event_loop_mainloop(void)
{
fd_set rfds, wfds;
int max_fd = -1;
int i;
int retval;
SpiceWatch *watch;
SpiceTimer *next_timer;
RingItem *link;
RingItem *next;
struct timeval next_timer_timeout;
struct timeval *timeout;
while (1) {
FD_ZERO(&rfds);
FD_ZERO(&wfds);
for (i = 0 ; i < watch_count; ++i) {
Watch* watch = &watches[i];
watch = (SpiceWatch*)watches.next;
i = 0;
RING_FOREACH_SAFE(link, next, &watches) {
watch = (SpiceWatch*)link;
if (watch->event_mask & SPICE_WATCH_EVENT_READ) {
FD_SET(watch->fd, &rfds);
max_fd = watch->fd > max_fd ? watch->fd : max_fd;
@ -106,21 +312,43 @@ void basic_event_loop_mainloop(void)
FD_SET(watch->fd, &wfds);
max_fd = watch->fd > max_fd ? watch->fd : max_fd;
}
i++;
}
if ((next_timer = get_next_timer()) != NULL) {
calc_next_timeout(next_timer, &next_timer_timeout);
timeout = &next_timer_timeout;
DPRINTF(1, "timeout of %d.%06d",
timeout->tv_sec, timeout->tv_usec);
} else {
timeout = NULL;
}
DPRINTF(1, "watching %d fds", i);
retval = select(max_fd + 1, &rfds, &wfds, NULL, timeout);
if (timeout != NULL) {
calc_next_timeout(next_timer, &next_timer_timeout);
if (next_timer_timeout.tv_sec == 0 &&
next_timer_timeout.tv_usec == 0) {
timeout_timers();
}
}
retval = select(max_fd + 1, &rfds, &wfds, NULL, NULL);
if (retval == -1) {
printf("error in select - exiting\n");
exit(-1);
abort();
}
if (retval) {
for (i = 0 ; i < watch_count; ++i) {
Watch* watch = &watches[i];
if ((watch->event_mask & SPICE_WATCH_EVENT_READ) && FD_ISSET(watch->fd, &rfds)) {
RING_FOREACH_SAFE(link, next, &watches) {
watch = (SpiceWatch*)link;
if ((watch->event_mask & SPICE_WATCH_EVENT_READ)
&& FD_ISSET(watch->fd, &rfds)) {
watch->func(watch->fd, SPICE_WATCH_EVENT_READ, watch->opaque);
}
if ((watch->event_mask & SPICE_WATCH_EVENT_WRITE) && FD_ISSET(watch->fd, &wfds)) {
if (!watch->remove && (watch->event_mask & SPICE_WATCH_EVENT_WRITE)
&& FD_ISSET(watch->fd, &wfds)) {
watch->func(watch->fd, SPICE_WATCH_EVENT_WRITE, watch->opaque);
}
if (watch->remove) {
free(watch);
}
}
}
}
@ -128,6 +356,8 @@ void basic_event_loop_mainloop(void)
SpiceCoreInterface *basic_event_loop_init(void)
{
ring_init(&watches);
ring_init(&timers);
bzero(&core, sizeof(core));
core.base.major_version = SPICE_INTERFACE_CORE_MAJOR;
core.base.minor_version = SPICE_INTERFACE_CORE_MINOR; // anything less then 3 and channel_event isn't called

291
server/tests/test_display_no_ssl.c Normal file
View File

@ -0,0 +1,291 @@
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <sys/select.h>
#include <spice.h>
#include <spice/qxl_dev.h>
#include "red_channel.h"
#include "test_util.h"
#include "basic_event_loop.h"
/* Parts cribbed from spice-display.h/.c/qxl.c */
typedef struct SimpleSpiceUpdate {
QXLDrawable drawable;
QXLImage image;
QXLCommandExt ext;
uint8_t *bitmap;
} SimpleSpiceUpdate;
void test_spice_destroy_update(SimpleSpiceUpdate *update)
{
free(update->bitmap);
free(update);
}
#define WIDTH 800
#define HEIGHT 600
static float angle = 0;
static int unique = 1;
static int color = 0;
SimpleSpiceUpdate *test_spice_create_update()
{
SimpleSpiceUpdate *update;
QXLDrawable *drawable;
QXLImage *image;
QXLCommand *cmd;
QXLRect bbox = {
.top = HEIGHT/2 + (HEIGHT/3)*cos(angle),
.left = WIDTH/2 + (WIDTH/3)*sin(angle),
};
uint8_t *dst;
int bw, bh;
int i;
angle += 0.1;
color = (color + 1) % 10;
unique++;
update = calloc(sizeof(*update), 1);
drawable = &update->drawable;
image = &update->image;
cmd = &update->ext.cmd;
bw = 64;
bh = 48;
bbox.right = bbox.left + bw;
bbox.bottom = bbox.top + bh;
update->bitmap = malloc(bw * bh * 4);
//printf("allocated %p, %p\n", update, update->bitmap);
drawable->bbox = bbox;
drawable->clip.type = SPICE_CLIP_TYPE_NONE;
drawable->effect = QXL_EFFECT_OPAQUE;
drawable->release_info.id = (intptr_t)update;
drawable->type = QXL_DRAW_COPY;
drawable->surfaces_dest[0] = -1;
drawable->surfaces_dest[1] = -1;
drawable->surfaces_dest[2] = -1;
drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
drawable->u.copy.src_bitmap = (intptr_t)image;
drawable->u.copy.src_area.right = bw;
drawable->u.copy.src_area.bottom = bh;
QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, unique);
image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
image->bitmap.flags = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
image->bitmap.stride = bw * 4;
image->descriptor.width = image->bitmap.x = bw;
image->descriptor.height = image->bitmap.y = bh;
image->bitmap.data = (intptr_t)(update->bitmap);
image->bitmap.palette = 0;
image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
dst = update->bitmap;
for (i = 0 ; i < bh * bw ; ++i, dst+=4) {
*dst = (color+i % 255);
*(dst+1) = 255 - color;
*(dst+2) = (color * (color + i)) & 0xff;
*(dst+3) = 0;
}
cmd->type = QXL_CMD_DRAW;
cmd->data = (intptr_t)drawable;
return update;
}
#define MEM_SLOT_GROUP_ID 0
static QXLWorker *qxl_worker = NULL;
static uint8_t primary_surface[HEIGHT * WIDTH * 4];
void create_test_primary_surface(QXLWorker *worker)
{
QXLDevSurfaceCreate surface;
surface.format = SPICE_SURFACE_FMT_32_xRGB;
surface.width = WIDTH;
surface.height = HEIGHT;
surface.stride = -WIDTH * 4;
surface.mouse_mode = TRUE;
surface.flags = 0;
surface.type = 0;
surface.mem = (intptr_t)&primary_surface;
surface.group_id = MEM_SLOT_GROUP_ID;
qxl_worker->create_primary_surface(qxl_worker, 0, &surface);
}
QXLDevMemSlot slot = {
.slot_group_id = MEM_SLOT_GROUP_ID,
.slot_id = 0,
.generation = 0,
.virt_start = 0,
.virt_end = ~0,
.addr_delta = 0,
.qxl_ram_size = ~0,
};
void attache_worker(QXLInstance *qin, QXLWorker *_qxl_worker)
{
static int count = 0;
if (++count > 1) {
printf("%s ignored\n", __func__);
return;
}
printf("%s\n", __func__);
qxl_worker = _qxl_worker;
qxl_worker->add_memslot(qxl_worker, &slot);
create_test_primary_surface(qxl_worker);
qxl_worker->start(qxl_worker);
}
void set_compression_level(QXLInstance *qin, int level)
{
printf("%s\n", __func__);
}
void set_mm_time(QXLInstance *qin, uint32_t mm_time)
{
}
void get_init_info(QXLInstance *qin, QXLDevInitInfo *info)
{
bzero(info, sizeof(*info));
info->num_memslots = 1;
info->num_memslots_groups = 1;
info->memslot_id_bits = 1;
info->memslot_gen_bits = 1;
info->n_surfaces = 1;
}
#define NOTIFY_BATCH 5
int notify = NOTIFY_BATCH;
int get_command(QXLInstance *qin, struct QXLCommandExt *ext)
{
SimpleSpiceUpdate *update;
if (!notify--) {
return FALSE;
}
update = test_spice_create_update();
*ext = update->ext;
notify = FALSE;
return TRUE;
}
SpiceTimer *wakeup_timer;
int wakeup_ms = 500;
int req_cmd_notification(QXLInstance *qin)
{
core->timer_start(wakeup_timer, wakeup_ms);
return TRUE;
}
void do_wakeup()
{
notify = NOTIFY_BATCH;
qxl_worker->wakeup(qxl_worker);
}
void release_resource(QXLInstance *qin, struct QXLReleaseInfoExt release_info)
{
//printf("%s\n", __func__);
ASSERT(release_info.group_id == MEM_SLOT_GROUP_ID);
test_spice_destroy_update((void*)release_info.info->id);
}
int get_cursor_command(QXLInstance *qin, struct QXLCommandExt *cmd)
{
//printf("%s\n", __func__);
return FALSE;
}
int req_cursor_notification(QXLInstance *qin)
{
printf("%s\n", __func__);
return TRUE;
}
void notify_update(QXLInstance *qin, uint32_t update_id)
{
printf("%s\n", __func__);
}
int flush_resources(QXLInstance *qin)
{
printf("%s\n", __func__);
}
QXLInterface display_sif = {
.base = {
.type = SPICE_INTERFACE_QXL,
.description = "test",
.major_version = SPICE_INTERFACE_QXL_MAJOR,
.minor_version = SPICE_INTERFACE_QXL_MINOR
},
.attache_worker = attache_worker,
.set_compression_level = set_compression_level,
.set_mm_time = set_mm_time,
.get_init_info = get_init_info,
.get_command = get_command,
.req_cmd_notification = req_cmd_notification,
.release_resource = release_resource,
.get_cursor_command = get_cursor_command,
.req_cursor_notification = req_cursor_notification,
.notify_update = notify_update,
.flush_resources = flush_resources,
};
QXLInstance display_sin = {
.base = {
.sif = &display_sif.base,
},
.id = 0,
};
SpiceServer *server;
SpiceCoreInterface *core;
SpiceTimer *ping_timer;
void show_channels(SpiceServer *server);
int ping_ms = 100;
void pinger(void *opaque)
{
// show_channels is not thread safe - fails if disconnections / connections occur
//show_channels(server);
core->timer_start(ping_timer, ping_ms);
}
int main()
{
core = basic_event_loop_init();
server = spice_server_new();
bzero(primary_surface, sizeof(primary_surface));
spice_server_set_port(server, 5912);
spice_server_set_noauth(server);
spice_server_init(server, core);
//spice_server_set_image_compression(server, SPICE_IMAGE_COMPRESS_OFF);
spice_server_add_interface(server, &display_sin.base);
ping_timer = core->timer_add(pinger, NULL);
wakeup_timer = core->timer_add(do_wakeup, NULL);
core->timer_start(ping_timer, ping_ms);
basic_event_loop_mainloop();
return 0;
}

12
server/tests/test_util.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __TEST_UTIL_H__
#define __TEST_UTIL_H__
#define TRUE 1
#define FALSE 0
#define ASSERT(x) if (!(x)) { \
printf("%s: ASSERT %s failed\n", __FUNCTION__, #x); \
abort(); \
}
#endif // __TEST_UTIL_H__