pxcloud/spice
6
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-08-08 16:48:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename all RedPipeItem subclasses

Browse Source 
Use 'Red' prefix to match internal type naming convention

Acked-by: Frediano Ziglio <fziglio@redhat.com>
This commit is contained in:
Jonathon Jongsma 2016-04-14 14:39:10 -05:00
parent b9720d80e0
commit 920e117c24
18 changed files with 529 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
server/cache-item.h
View File

@ -21,14 +21,14 @@
#include "red-channel.h"
#include "common/ring.h"
typedef struct CacheItem CacheItem;
typedef struct RedCacheItem RedCacheItem;
struct CacheItem {
struct RedCacheItem {
union {
RedPipeItem pipe_data;
struct {
RingItem lru_link;
CacheItem *next;
RedCacheItem *next;
} cache_data;
} u;
uint64_t id;

18
server/cache-item.tmpl.c
View File

@ -48,9 +48,9 @@
#define CHANNEL_FROM_RCC(rcc) SPICE_CONTAINEROF((rcc)->channel, CHANNEL, common.base);
static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
static RedCacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
{
CacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
RedCacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
while (item) {
if (item->id == id) {
@ -63,9 +63,9 @@ static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
return item;
}
static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
{
CacheItem **now;
RedCacheItem **now;
spice_assert(item);
now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)];
@ -81,20 +81,20 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
channel_client->VAR_NAME(items)--;
channel_client->VAR_NAME(available) += item->size;
red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
red_pipe_item_init(&item->u.pipe_data, RED_PIPE_ITEM_TYPE_INVAL_ONE);
red_channel_client_pipe_add_tail_and_push(&channel_client->common.base, &item->u.pipe_data); // for now
}
static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t size)
{
CacheItem *item;
RedCacheItem *item;
int key;
item = spice_new(CacheItem, 1);
item = spice_new(RedCacheItem, 1);
channel_client->VAR_NAME(available) -= size;
while (channel_client->VAR_NAME(available) < 0) {
CacheItem *tail = (CacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
RedCacheItem *tail = (RedCacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
if (!tail) {
channel_client->VAR_NAME(available) += size;
free(item);
@ -119,7 +119,7 @@ static void FUNC_NAME(reset)(CHANNELCLIENT *channel_client, long size)
for (i = 0; i < CACHE_HASH_SIZE; i++) {
while (channel_client->CACHE_NAME[i]) {
CacheItem *item = channel_client->CACHE_NAME[i];
RedCacheItem *item = channel_client->CACHE_NAME[i];
channel_client->CACHE_NAME[i] = item->u.cache_data.next;
free(item);
}

71
server/cursor-channel.c
View File

@ -32,9 +32,9 @@
#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
enum {
PIPE_ITEM_TYPE_CURSOR = PIPE_ITEM_TYPE_COMMON_LAST,
PIPE_ITEM_TYPE_CURSOR_INIT,
PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
RED_PIPE_ITEM_TYPE_CURSOR = RED_PIPE_ITEM_TYPE_COMMON_LAST,
RED_PIPE_ITEM_TYPE_CURSOR_INIT,
RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
};
typedef struct CursorItem {
@ -45,11 +45,11 @@ typedef struct CursorItem {
G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
typedef struct CursorPipeItem {
typedef struct RedCursorPipeItem {
RedPipeItem base;
CursorItem *cursor_item;
int refs;
} CursorPipeItem;
} RedCursorPipeItem;
struct CursorChannel {
CommonGraphicsChannel common; // Must be the first thing
@ -69,7 +69,7 @@ struct CursorChannel {
struct CursorChannelClient {
CommonGraphicsChannelClient common;
CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
RedCacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
Ring cursor_cache_lru;
long cursor_cache_available;
uint32_t cursor_cache_items;
@ -134,9 +134,9 @@ static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
{
CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
RedCursorPipeItem *item = spice_malloc0(sizeof(RedCursorPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_CURSOR);
item->refs = 1;
item->cursor_item = data;
item->cursor_item->refs++;
@ -203,7 +203,8 @@ void cursor_channel_disconnect(CursorChannel *cursor_channel)
}
static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_item)
static void put_cursor_pipe_item(CursorChannelClient *ccc,
RedCursorPipeItem *pipe_item)
{
spice_return_if_fail(pipe_item);
spice_return_if_fail(pipe_item->refs > 0);
@ -232,15 +233,15 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
case RED_PIPE_ITEM_TYPE_CURSOR: {
RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
case PIPE_ITEM_TYPE_INVAL_ONE:
case PIPE_ITEM_TYPE_VERB:
case PIPE_ITEM_TYPE_CURSOR_INIT:
case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
case RED_PIPE_ITEM_TYPE_INVAL_ONE:
case RED_PIPE_ITEM_TYPE_VERB:
case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
free(item);
break;
default:
@ -252,8 +253,8 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
case RED_PIPE_ITEM_TYPE_CURSOR: {
RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
@ -285,7 +286,8 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas
}
static void cursor_marshall(RedChannelClient *rcc,
SpiceMarshaller *m, CursorPipeItem *cursor_pipe_item)
SpiceMarshaller *m,
RedCursorPipeItem *cursor_pipe_item)
{
CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@ -338,7 +340,8 @@ static void cursor_marshall(RedChannelClient *rcc,
}
static inline void red_marshall_inval(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller, CacheItem *cach_item)
SpiceMarshaller *base_marshaller,
RedCacheItem *cach_item)
{
SpiceMsgDisplayInvalOne inval_one;
@ -354,20 +357,20 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
switch (pipe_item->type) {
case PIPE_ITEM_TYPE_CURSOR:
cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, CursorPipeItem, base));
case RED_PIPE_ITEM_TYPE_CURSOR:
cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, RedCursorPipeItem, base));
break;
case PIPE_ITEM_TYPE_INVAL_ONE:
red_marshall_inval(rcc, m, (CacheItem *)pipe_item);
case RED_PIPE_ITEM_TYPE_INVAL_ONE:
red_marshall_inval(rcc, m, (RedCacheItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_VERB:
red_marshall_verb(rcc, (VerbItem*)pipe_item);
case RED_PIPE_ITEM_TYPE_VERB:
red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
case PIPE_ITEM_TYPE_CURSOR_INIT:
case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
red_reset_cursor_cache(rcc);
red_marshall_cursor_init(rcc, m, pipe_item);
break;
case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
red_reset_cursor_cache(rcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INVAL_ALL, NULL);
break;
@ -379,7 +382,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
red_channel_client_begin_send_message(rcc);
}
static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
static RedCursorPipeItem *cursor_pipe_item_ref(RedCursorPipeItem *item)
{
spice_return_val_if_fail(item, NULL);
spice_return_val_if_fail(item->refs > 0, NULL);
@ -391,11 +394,11 @@ static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
CursorPipeItem *cursor_pipe_item;
RedCursorPipeItem *cursor_pipe_item;
spice_return_if_fail(item);
cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
cursor_pipe_item_ref(cursor_pipe_item);
}
@ -443,7 +446,7 @@ void cursor_channel_client_migrate(CursorChannelClient* client)
spice_return_if_fail(client);
rcc = RED_CHANNEL_CLIENT(client);
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
red_channel_client_default_migrate(rcc);
}
@ -531,7 +534,7 @@ void cursor_channel_reset(CursorChannel *cursor)
cursor->cursor_trail_length = cursor->cursor_trail_frequency = 0;
if (red_channel_is_connected(channel)) {
red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
if (!cursor->common.during_target_migrate) {
red_pipes_add_verb(channel, SPICE_MSG_CURSOR_RESET);
}
@ -555,9 +558,9 @@ void cursor_channel_init(CursorChannel *cursor, CursorChannelClient *client)
if (client)
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(client),
PIPE_ITEM_TYPE_CURSOR_INIT);
RED_PIPE_ITEM_TYPE_CURSOR_INIT);
else
red_channel_pipes_add_type(RED_CHANNEL(cursor), PIPE_ITEM_TYPE_CURSOR_INIT);
red_channel_pipes_add_type(RED_CHANNEL(cursor), RED_PIPE_ITEM_TYPE_CURSOR_INIT);
}
void cursor_channel_set_mouse_mode(CursorChannel *cursor, uint32_t mode)

155
server/dcc-send.c
View File

@ -514,7 +514,7 @@ static void fill_attr(SpiceMarshaller *m, SpiceLineAttr *attr)
static void marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -608,9 +608,9 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
{
Drawable *drawable;
if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
drawable = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item)->drawable;
drawable = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item)->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@ -699,12 +699,12 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
pipe_item;
pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
Drawable *drawable;
DrawablePipeItem *dpi;
ImageItem *image;
RedDrawablePipeItem *dpi;
RedImageItem *image;
if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@ -803,7 +803,7 @@ static void red_add_lossless_drawable_dependencies(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *m,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -860,7 +860,8 @@ static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi, int src_allowed_lossy)
RedDrawablePipeItem *dpi,
int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -893,7 +894,7 @@ static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *m,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -958,7 +959,8 @@ static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi, int src_allowed_lossy)
RedDrawablePipeItem *dpi,
int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -984,7 +986,7 @@ static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -1009,7 +1011,7 @@ static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@ -1029,7 +1031,7 @@ static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -1056,7 +1058,7 @@ static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi,
RedDrawablePipeItem *dpi,
int src_allowed_lossy)
{
Drawable *item = dpi->drawable;
@ -1081,7 +1083,7 @@ static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1108,7 +1110,7 @@ static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -1123,7 +1125,7 @@ static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1152,7 +1154,7 @@ static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1176,7 +1178,7 @@ static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1218,7 +1220,7 @@ static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -1238,7 +1240,7 @@ static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1252,7 +1254,7 @@ static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -1272,7 +1274,7 @@ static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1312,7 +1314,7 @@ static void red_lossy_marshall_qxl_draw_inverse(RedChannelClient *rcc,
static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1341,7 +1343,7 @@ static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1396,7 +1398,7 @@ static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1421,7 +1423,7 @@ static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1477,7 +1479,7 @@ static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1502,7 +1504,7 @@ static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1557,7 +1559,7 @@ static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1584,7 +1586,7 @@ static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@ -1768,8 +1770,8 @@ static int red_marshall_stream_data(RedChannelClient *rcc,
}
static inline void marshall_inval_palette(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
CacheItem *cache_item)
SpiceMarshaller *base_marshaller,
RedCacheItem *cache_item)
{
SpiceMsgDisplayInvalOne inval_one;
@ -1915,7 +1917,9 @@ static void display_channel_marshall_reset_cache(RedChannelClient *rcc,
&wait);
}
static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageItem *item)
static void red_marshall_image(RedChannelClient *rcc,
SpiceMarshaller *m,
RedImageItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display = DCC_TO_DC(dcc);
@ -2009,7 +2013,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI
static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
DrawablePipeItem *dpi)
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
switch (item->red_drawable->type) {
@ -2061,7 +2065,8 @@ static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
SpiceMarshaller *m, DrawablePipeItem *dpi)
SpiceMarshaller *m,
RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@ -2115,7 +2120,8 @@ static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_qxl_drawable(RedChannelClient *rcc,
SpiceMarshaller *m, DrawablePipeItem *dpi)
SpiceMarshaller *m,
RedDrawablePipeItem *dpi)
{
spice_return_if_fail(rcc);
@ -2173,7 +2179,7 @@ static void marshall_stream_start(RedChannelClient *rcc,
static void marshall_stream_clip(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
StreamClipItem *item)
RedStreamClipItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
StreamAgent *agent = item->stream_agent;
@ -2203,7 +2209,7 @@ static void marshall_stream_end(RedChannelClient *rcc,
}
static void marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller *m,
UpgradeItem *item)
RedUpgradeItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
RedDrawable *red_drawable;
@ -2319,7 +2325,7 @@ static void marshall_gl_draw(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
RedGlDrawItem *p = SPICE_CONTAINEROF(item, RedGlDrawItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_DRAW, NULL);
spice_marshall_msg_display_gl_draw(m, &p->draw);
@ -2367,80 +2373,81 @@ void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
reset_send_data(dcc);
switch (pipe_item->type) {
case PIPE_ITEM_TYPE_DRAW: {
DrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
case RED_PIPE_ITEM_TYPE_DRAW: {
RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
marshall_qxl_drawable(rcc, m, dpi);
break;
}
case PIPE_ITEM_TYPE_INVAL_ONE:
marshall_inval_palette(rcc, m, (CacheItem *)pipe_item);
case RED_PIPE_ITEM_TYPE_INVAL_ONE:
marshall_inval_palette(rcc, m, (RedCacheItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_STREAM_CREATE: {
case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, create_item);
marshall_stream_start(rcc, m, agent);
break;
}
case PIPE_ITEM_TYPE_STREAM_CLIP: {
StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
case RED_PIPE_ITEM_TYPE_STREAM_CLIP: {
RedStreamClipItem* clip_item = (RedStreamClipItem *)pipe_item;
marshall_stream_clip(rcc, m, clip_item);
break;
}
case PIPE_ITEM_TYPE_STREAM_DESTROY: {
case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, destroy_item);
marshall_stream_end(rcc, m, agent);
break;
}
case PIPE_ITEM_TYPE_UPGRADE:
marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
case RED_PIPE_ITEM_TYPE_UPGRADE:
marshall_upgrade(rcc, m, (RedUpgradeItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_VERB:
red_marshall_verb(rcc, (VerbItem*)pipe_item);
case RED_PIPE_ITEM_TYPE_VERB:
red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
case PIPE_ITEM_TYPE_MIGRATE_DATA:
case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
display_channel_marshall_migrate_data(rcc, m);
break;
case PIPE_ITEM_TYPE_IMAGE:
red_marshall_image(rcc, m, (ImageItem *)pipe_item);
case RED_PIPE_ITEM_TYPE_IMAGE:
red_marshall_image(rcc, m, (RedImageItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_PIXMAP_SYNC:
case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
display_channel_marshall_pixmap_sync(rcc, m);
break;
case PIPE_ITEM_TYPE_PIXMAP_RESET:
case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
display_channel_marshall_reset_cache(rcc, m);
break;
case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
dcc_palette_cache_reset(dcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, NULL);
break;
case PIPE_ITEM_TYPE_CREATE_SURFACE: {
SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, SurfaceCreateItem,
pipe_item);
case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, RedSurfaceCreateItem,
pipe_item);
marshall_surface_create(rcc, m, &surface_create->surface_create);
break;
}
case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, SurfaceDestroyItem,
pipe_item);
case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, RedSurfaceDestroyItem,
pipe_item);
marshall_surface_destroy(rcc, m, surface_destroy->surface_destroy.surface_id);
break;
}
case PIPE_ITEM_TYPE_MONITORS_CONFIG: {
MonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
MonitorsConfigItem, pipe_item);
case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG: {
RedMonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
RedMonitorsConfigItem,
pipe_item);
marshall_monitors_config(rcc, m, monconf_item->monitors_config);
break;
}
case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
StreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
StreamActivateReportItem,
pipe_item);
case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
RedStreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
RedStreamActivateReportItem,
pipe_item);
marshall_stream_activate_report(rcc, m, report_item->stream_id);
break;
}
case PIPE_ITEM_TYPE_GL_SCANOUT:
case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
marshall_gl_scanout(rcc, m, pipe_item);
break;
case PIPE_ITEM_TYPE_GL_DRAW:
case RED_PIPE_ITEM_TYPE_GL_DRAW:
marshall_gl_draw(rcc, m, pipe_item);
break;
default:

189
server/dcc.c
View File

@ -24,13 +24,16 @@
#define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano
static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
uint32_t surface_id, uint32_t width,
uint32_t height, uint32_t format, uint32_t flags)
static RedSurfaceCreateItem *red_surface_create_item_new(RedChannel* channel,
uint32_t surface_id,
uint32_t width,
uint32_t height,
uint32_t format,
uint32_t flags)
{
SurfaceCreateItem *create;
RedSurfaceCreateItem *create;
create = spice_malloc(sizeof(SurfaceCreateItem));
create = spice_malloc(sizeof(RedSurfaceCreateItem));
create->surface_create.surface_id = surface_id;
create->surface_create.width = width;
@ -38,13 +41,13 @@ static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
create->surface_create.flags = flags;
create->surface_create.format = format;
red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
red_pipe_item_init(&create->pipe_item, RED_PIPE_ITEM_TYPE_CREATE_SURFACE);
return create;
}
int dcc_drawable_is_in_pipe(DisplayChannelClient *dcc, Drawable *drawable)
{
DrawablePipeItem *dpi;
RedDrawablePipeItem *dpi;
RingItem *dpi_link, *dpi_next;
DRAWABLE_FOREACH_DPI_SAFE(drawable, dpi_link, dpi_next, dpi) {
@ -77,14 +80,14 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
item = (RedPipeItem *) ring;
while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
Drawable *drawable;
DrawablePipeItem *dpi = NULL;
RedDrawablePipeItem *dpi = NULL;
int depend_found = FALSE;
if (item->type == PIPE_ITEM_TYPE_DRAW) {
dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
if (item->type == RED_PIPE_ITEM_TYPE_DRAW) {
dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
} else if (item->type == PIPE_ITEM_TYPE_UPGRADE) {
drawable = ((UpgradeItem *)item)->drawable;
} else if (item->type == RED_PIPE_ITEM_TYPE_UPGRADE) {
drawable = ((RedUpgradeItem *)item)->drawable;
} else {
continue;
}
@ -138,7 +141,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
{
DisplayChannel *display;
RedSurface *surface;
SurfaceCreateItem *create;
RedSurfaceCreateItem *create;
uint32_t flags;
if (!dcc) {
@ -154,21 +157,25 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
return;
}
surface = &display->surfaces[surface_id];
create = surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
surface_id, surface->context.width, surface->context.height,
surface->context.format, flags);
create = red_surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
surface_id, surface->context.width,
surface->context.height,
surface->context.format, flags);
dcc->surface_client_created[surface_id] = TRUE;
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &create->pipe_item);
}
// adding the pipe item after pos. If pos == NULL, adding to head.
ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
SpiceRect *area, RedPipeItem *pos, int can_lossy)
RedImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
RedPipeItem *pos,
int can_lossy)
{
DisplayChannel *display = DCC_TO_DC(dcc);
RedSurface *surface = &display->surfaces[surface_id];
SpiceCanvas *canvas = surface->context.canvas;
ImageItem *item;
RedImageItem *item;
int stride;
int width;
int height;
@ -182,9 +189,9 @@ ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
bpp = SPICE_SURFACE_FMT_DEPTH(surface->context.format) / 8;
stride = width * bpp;
item = (ImageItem *)spice_malloc_n_m(height, stride, sizeof(ImageItem));
item = (RedImageItem *)spice_malloc_n_m(height, stride, sizeof(RedImageItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_IMAGE);
item->surface_id = surface_id;
item->image_format =
@ -274,9 +281,10 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
dcc_push_surface_image(dcc, drawable->surface_id);
}
void drawable_pipe_item_free(RedPipeItem *item)
void red_drawable_pipe_item_free(RedPipeItem *item)
{
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem,
dpi_pipe_item);
spice_assert(item->refcount == 0);
spice_warn_if_fail(!ring_item_is_linked(&item->link));
@ -285,24 +293,25 @@ void drawable_pipe_item_free(RedPipeItem *item)
free(dpi);
}
static DrawablePipeItem *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawable *drawable)
static RedDrawablePipeItem *red_drawable_pipe_item_new(DisplayChannelClient *dcc,
Drawable *drawable)
{
DrawablePipeItem *dpi;
RedDrawablePipeItem *dpi;
dpi = spice_malloc0(sizeof(*dpi));
dpi->drawable = drawable;
dpi->dcc = dcc;
ring_item_init(&dpi->base);
ring_add(&drawable->pipes, &dpi->base);
red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
(GDestroyNotify)drawable_pipe_item_free);
red_pipe_item_init_full(&dpi->dpi_pipe_item, RED_PIPE_ITEM_TYPE_DRAW,
(GDestroyNotify)red_drawable_pipe_item_free);
drawable->refs++;
return dpi;
}
void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@ -310,7 +319,7 @@ void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@ -318,7 +327,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, RedPipeItem *pos)
{
DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_after(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item, pos);
@ -334,8 +343,8 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
agent->stream = &display->streams_buf[i];
region_init(&agent->vis_region);
region_init(&agent->clip);
red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
red_pipe_item_init(&agent->create_item, RED_PIPE_ITEM_TYPE_STREAM_CREATE);
red_pipe_item_init(&agent->destroy_item, RED_PIPE_ITEM_TYPE_STREAM_DESTROY);
}
dcc->use_mjpeg_encoder_rate_control =
red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
@ -445,7 +454,7 @@ void dcc_start(DisplayChannelClient *dcc)
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
if (display->surfaces[0].context.canvas) {
display_channel_current_flush(display, 0);
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
dcc_create_surface(dcc, 0);
dcc_push_surface_image(dcc, 0);
dcc_push_monitors_config(dcc);
@ -495,7 +504,7 @@ void dcc_stop(DisplayChannelClient *dcc)
void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
{
StreamClipItem *item = stream_clip_item_new(agent);
RedStreamClipItem *item = red_stream_clip_item_new(agent);
int n_rects;
item->clip_type = SPICE_CLIP_TYPE_RECTS;
@ -508,22 +517,22 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem *)item);
}
static void monitors_config_item_free(MonitorsConfigItem *item)
static void red_monitors_config_item_free(RedMonitorsConfigItem *item)
{
monitors_config_unref(item->monitors_config);
free(item);
}
static MonitorsConfigItem *monitors_config_item_new(RedChannel* channel,
MonitorsConfig *monitors_config)
static RedMonitorsConfigItem *red_monitors_config_item_new(RedChannel* channel,
MonitorsConfig *monitors_config)
{
MonitorsConfigItem *mci;
RedMonitorsConfigItem *mci;
mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci = (RedMonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci->monitors_config = monitors_config;
red_pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
(GDestroyNotify)monitors_config_item_free);
red_pipe_item_init_full(&mci->pipe_item, RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
(GDestroyNotify)red_monitors_config_item_free);
return mci;
}
@ -531,7 +540,7 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
{
DisplayChannel *dc = DCC_TO_DC(dcc);
MonitorsConfig *monitors_config = dc->monitors_config;
MonitorsConfigItem *mci;
RedMonitorsConfigItem *mci;
if (monitors_config == NULL) {
spice_warning("monitors_config is NULL");
@ -543,27 +552,27 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
return;
}
mci = monitors_config_item_new(dcc->common.base.channel,
monitors_config_ref(dc->monitors_config));
mci = red_monitors_config_item_new(dcc->common.base.channel,
monitors_config_ref(dc->monitors_config));
red_channel_client_pipe_add(&dcc->common.base, &mci->pipe_item);
red_channel_client_push(&dcc->common.base);
}
static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel,
uint32_t surface_id)
static RedSurfaceDestroyItem *red_surface_destroy_item_new(RedChannel *channel,
uint32_t surface_id)
{
SurfaceDestroyItem *destroy;
RedSurfaceDestroyItem *destroy;
destroy = spice_malloc(sizeof(SurfaceDestroyItem));
destroy = spice_malloc(sizeof(RedSurfaceDestroyItem));
destroy->surface_destroy.surface_id = surface_id;
red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
red_pipe_item_init(&destroy->pipe_item, RED_PIPE_ITEM_TYPE_DESTROY_SURFACE);
return destroy;
}
RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
{
GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
RedGlScanoutUnixItem *item = spice_new(RedGlScanoutUnixItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
/* FIXME: on !unix peer, start streaming with a video codec */
@ -574,7 +583,7 @@ RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
return NULL;
}
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_SCANOUT);
return &item->base;
}
@ -583,7 +592,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
const SpiceMsgDisplayGlDraw *draw = data;
GlDrawItem *item = spice_new(GlDrawItem, 1);
RedGlDrawItem *item = spice_new(RedGlDrawItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
if (!red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) {
@ -594,7 +603,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
dcc->gl_draw_ongoing = TRUE;
item->draw = *draw;
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_DRAW);
return &item->base;
}
@ -603,7 +612,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
{
DisplayChannel *display;
RedChannel *channel;
SurfaceDestroyItem *destroy;
RedSurfaceDestroyItem *destroy;
if (!dcc) {
return;
@ -618,7 +627,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
}
dcc->surface_client_created[surface_id] = FALSE;
destroy = surface_destroy_item_new(channel, surface_id);
destroy = red_surface_destroy_item_new(channel, surface_id);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy->pipe_item);
}
@ -1300,7 +1309,7 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
if (cache->generation != dcc->pixmap_cache_generation) {
if (!dcc->pending_pixmaps_sync) {
red_channel_client_pipe_add_type(
RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_SYNC);
RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_SYNC);
dcc->pending_pixmaps_sync = TRUE;
}
free(item);
@ -1552,9 +1561,9 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
if (migrate_data->pixmap_cache_freezer) {
/* activating the cache. The cache will start to be active after
* pixmap_cache_reset is called, when handling PIPE_ITEM_TYPE_PIXMAP_RESET */
* pixmap_cache_reset is called, when handling RED_PIPE_ITEM_TYPE_PIXMAP_RESET */
dcc->pixmap_cache->size = migrate_data->pixmap_cache_size;
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_RESET);
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_RESET);
}
if (dcc_handle_migrate_glz_dictionary(dcc, migrate_data)) {
@ -1583,7 +1592,7 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
spice_return_val_if_fail(surfaces_restored, FALSE);
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
/* enable sending messages */
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
return TRUE;
@ -1592,16 +1601,16 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
static void release_item_after_push(RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
case PIPE_ITEM_TYPE_UPGRADE:
case RED_PIPE_ITEM_TYPE_DRAW:
case RED_PIPE_ITEM_TYPE_IMAGE:
case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
case RED_PIPE_ITEM_TYPE_UPGRADE:
red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
case PIPE_ITEM_TYPE_VERB:
case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
case RED_PIPE_ITEM_TYPE_GL_DRAW:
case RED_PIPE_ITEM_TYPE_VERB:
free(item);
break;
default:
@ -1617,49 +1626,49 @@ static void release_item_before_push(DisplayChannelClient *dcc, RedPipeItem *ite
spice_debug("item.type: %d", item->type);
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW: {
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
case RED_PIPE_ITEM_TYPE_DRAW: {
RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
ring_remove(&dpi->base);
red_pipe_item_unref(item);
break;
}
case PIPE_ITEM_TYPE_STREAM_CREATE: {
case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, create_item);
stream_agent_unref(display, agent);
break;
}
case PIPE_ITEM_TYPE_STREAM_DESTROY: {
case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, destroy_item);
stream_agent_unref(display, agent);
break;
}
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
case RED_PIPE_ITEM_TYPE_UPGRADE:
case RED_PIPE_ITEM_TYPE_IMAGE:
case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_CREATE_SURFACE: {
SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, SurfaceCreateItem,
pipe_item);
case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, RedSurfaceCreateItem,
pipe_item);
free(surface_create);
break;
}
case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, SurfaceDestroyItem,
pipe_item);
case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, RedSurfaceDestroyItem,
pipe_item);
free(surface_destroy);
break;
}
case PIPE_ITEM_TYPE_INVAL_ONE:
case PIPE_ITEM_TYPE_VERB:
case PIPE_ITEM_TYPE_MIGRATE_DATA:
case PIPE_ITEM_TYPE_PIXMAP_SYNC:
case PIPE_ITEM_TYPE_PIXMAP_RESET:
case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
case RED_PIPE_ITEM_TYPE_INVAL_ONE:
case RED_PIPE_ITEM_TYPE_VERB:
case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
case RED_PIPE_ITEM_TYPE_GL_DRAW:
free(item);
break;
default:

24
server/dcc.h
View File

@ -82,7 +82,7 @@ struct DisplayChannelClient {
uint32_t pixmap_cache_generation;
int pending_pixmaps_sync;
CacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
RedCacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
Ring palette_cache_lru;
long palette_cache_available;
uint32_t palette_cache_items;
@ -121,21 +121,21 @@ struct DisplayChannelClient {
SPICE_CONTAINEROF((dcc)->common.base.channel, DisplayChannel, common.base)
#define RCC_TO_DCC(rcc) SPICE_CONTAINEROF((rcc), DisplayChannelClient, common.base)
typedef struct SurfaceCreateItem {
typedef struct RedSurfaceCreateItem {
SpiceMsgSurfaceCreate surface_create;
RedPipeItem pipe_item;
} SurfaceCreateItem;
} RedSurfaceCreateItem;
typedef struct GlScanoutUnixItem {
typedef struct RedGlScanoutUnixItem {
RedPipeItem base;
} GlScanoutUnixItem;
} RedGlScanoutUnixItem;
typedef struct GlDrawItem {
typedef struct RedGlDrawItem {
RedPipeItem base;
SpiceMsgDisplayGlDraw draw;
} GlDrawItem;
} RedGlDrawItem;
typedef struct ImageItem {
typedef struct RedImageItem {
RedPipeItem base;
SpicePoint pos;
int width;
@ -147,15 +147,15 @@ typedef struct ImageItem {
uint32_t image_flags;
int can_lossy;
uint8_t data[0];
} ImageItem;
} RedImageItem;
typedef struct DrawablePipeItem {
typedef struct RedDrawablePipeItem {
RingItem base; /* link for a list of pipe items held by Drawable */
RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
Drawable *drawable;
DisplayChannelClient *dcc;
uint8_t refs;
} DrawablePipeItem;
} RedDrawablePipeItem;
DisplayChannelClient* dcc_new (DisplayChannel *display,
RedClient *client,
@ -186,7 +186,7 @@ void dcc_create_surface (DisplayCha
int surface_id);
void dcc_push_surface_image (DisplayChannelClient *dcc,
int surface_id);
ImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
RedImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
RedPipeItem *pos,

22
server/display-channel.c
View File

@ -337,7 +337,7 @@ static void pipes_add_drawable(DisplayChannel *display, Drawable *drawable)
static void pipes_add_drawable_after(DisplayChannel *display,
Drawable *drawable, Drawable *pos_after)
{
DrawablePipeItem *dpi_pos_after;
RedDrawablePipeItem *dpi_pos_after;
RingItem *dpi_link, *dpi_next;
DisplayChannelClient *dcc;
int num_other_linked = 0;
@ -396,11 +396,11 @@ static void current_remove_drawable(DisplayChannel *display, Drawable *item)
static void drawable_remove_from_pipes(Drawable *drawable)
{
DrawablePipeItem *dpi;
RedDrawablePipeItem *dpi;
RingItem *item, *next;
RING_FOREACH_SAFE(item, next, &drawable->pipes) {
dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, base);
if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi->dcc),
&dpi->dpi_pipe_item);
@ -497,7 +497,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
if (is_same_drawable(drawable, other_drawable)) {
DisplayChannelClient *dcc;
DrawablePipeItem *dpi;
RedDrawablePipeItem *dpi;
RingItem *worker_ring_item, *dpi_ring_item;
other_drawable->refs++;
@ -511,7 +511,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
while (worker_ring_item) {
dcc = SPICE_CONTAINEROF(worker_ring_item, DisplayChannelClient,
common.base.channel_link);
dpi = SPICE_CONTAINEROF(dpi_ring_item, DrawablePipeItem, base);
dpi = SPICE_CONTAINEROF(dpi_ring_item, RedDrawablePipeItem, base);
while (worker_ring_item && (!dpi || dcc != dpi->dcc)) {
dcc_prepend_drawable(dcc, drawable);
worker_ring_item = ring_next(&RED_CHANNEL(display)->clients,
@ -1847,7 +1847,7 @@ void display_channel_destroy_surfaces(DisplayChannel *display)
spice_warn_if_fail(ring_is_empty(&display->streams));
if (red_channel_is_connected(RED_CHANNEL(display))) {
red_channel_pipes_add_type(RED_CHANNEL(display), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_channel_pipes_add_type(RED_CHANNEL(display), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_pipes_add_verb(RED_CHANNEL(display), SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL);
}
@ -1968,10 +1968,10 @@ static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
spice_return_if_fail(item);
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
case RED_PIPE_ITEM_TYPE_DRAW:
case RED_PIPE_ITEM_TYPE_IMAGE:
case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
case RED_PIPE_ITEM_TYPE_UPGRADE:
red_pipe_item_ref(item);
break;
default:
@ -1992,7 +1992,7 @@ static int handle_migrate_flush_mark(RedChannelClient *rcc)
DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base);
RedChannel *channel = RED_CHANNEL(display_channel);
red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_MIGRATE_DATA);
red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_MIGRATE_DATA);
return TRUE;
}

46
server/display-channel.h
View File

@ -84,7 +84,7 @@ struct Drawable {
void drawable_unref (Drawable *drawable);
#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), DrawablePipeItem, base)
#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), RedDrawablePipeItem, base)
#define DRAWABLE_FOREACH_DPI_SAFE(drawable, link, next, dpi) \
SAFE_FOREACH(link, next, drawable, &(drawable)->pipes, dpi, LINK_TO_DPI(link))
@ -94,22 +94,22 @@ void drawable_unref (Drawable *drawable);
SAFE_FOREACH(link, next, drawable, &(drawable)->glz_ring, glz, LINK_TO_GLZ(link))
enum {
PIPE_ITEM_TYPE_DRAW = PIPE_ITEM_TYPE_COMMON_LAST,
PIPE_ITEM_TYPE_IMAGE,
PIPE_ITEM_TYPE_STREAM_CREATE,
PIPE_ITEM_TYPE_STREAM_CLIP,
PIPE_ITEM_TYPE_STREAM_DESTROY,
PIPE_ITEM_TYPE_UPGRADE,
PIPE_ITEM_TYPE_MIGRATE_DATA,
PIPE_ITEM_TYPE_PIXMAP_SYNC,
PIPE_ITEM_TYPE_PIXMAP_RESET,
PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
PIPE_ITEM_TYPE_CREATE_SURFACE,
PIPE_ITEM_TYPE_DESTROY_SURFACE,
PIPE_ITEM_TYPE_MONITORS_CONFIG,
PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
PIPE_ITEM_TYPE_GL_SCANOUT,
PIPE_ITEM_TYPE_GL_DRAW,
RED_PIPE_ITEM_TYPE_DRAW = RED_PIPE_ITEM_TYPE_COMMON_LAST,
RED_PIPE_ITEM_TYPE_IMAGE,
RED_PIPE_ITEM_TYPE_STREAM_CREATE,
RED_PIPE_ITEM_TYPE_STREAM_CLIP,
RED_PIPE_ITEM_TYPE_STREAM_DESTROY,
RED_PIPE_ITEM_TYPE_UPGRADE,
RED_PIPE_ITEM_TYPE_MIGRATE_DATA,
RED_PIPE_ITEM_TYPE_PIXMAP_SYNC,
RED_PIPE_ITEM_TYPE_PIXMAP_RESET,
RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
RED_PIPE_ITEM_TYPE_CREATE_SURFACE,
RED_PIPE_ITEM_TYPE_DESTROY_SURFACE,
RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
RED_PIPE_ITEM_TYPE_GL_SCANOUT,
RED_PIPE_ITEM_TYPE_GL_DRAW,
};
typedef struct MonitorsConfig {
@ -119,10 +119,10 @@ typedef struct MonitorsConfig {
QXLHead heads[0];
} MonitorsConfig;
typedef struct MonitorsConfigItem {
typedef struct RedMonitorsConfigItem {
RedPipeItem pipe_item;
MonitorsConfig *monitors_config;
} MonitorsConfigItem;
} RedMonitorsConfigItem;
MonitorsConfig* monitors_config_new (QXLHead *heads, ssize_t nheads,
ssize_t max);
@ -240,16 +240,16 @@ static inline int get_stream_id(DisplayChannel *display, Stream *stream)
return (int)(stream - display->streams_buf);
}
typedef struct SurfaceDestroyItem {
typedef struct RedSurfaceDestroyItem {
SpiceMsgSurfaceDestroy surface_destroy;
RedPipeItem pipe_item;
} SurfaceDestroyItem;
} RedSurfaceDestroyItem;
typedef struct UpgradeItem {
typedef struct RedUpgradeItem {
RedPipeItem base;
Drawable *drawable;
SpiceClipRects *rects;
} UpgradeItem;
} RedUpgradeItem;
DisplayChannel* display_channel_new (SpiceServer *reds,

52
server/inputs-channel.c
View File

@ -116,25 +116,25 @@ struct InputsChannel {
};
enum {
PIPE_ITEM_INPUTS_INIT = PIPE_ITEM_TYPE_CHANNEL_BASE,
PIPE_ITEM_MOUSE_MOTION_ACK,
PIPE_ITEM_KEY_MODIFIERS,
PIPE_ITEM_MIGRATE_DATA,
RED_PIPE_ITEM_INPUTS_INIT = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_MOUSE_MOTION_ACK,
RED_PIPE_ITEM_KEY_MODIFIERS,
RED_PIPE_ITEM_MIGRATE_DATA,
};
typedef struct InputsPipeItem {
typedef struct RedInputsPipeItem {
RedPipeItem base;
} InputsPipeItem;
} RedInputsPipeItem;
typedef struct KeyModifiersPipeItem {
typedef struct RedKeyModifiersPipeItem {
RedPipeItem base;
uint8_t modifiers;
} KeyModifiersPipeItem;
} RedKeyModifiersPipeItem;
typedef struct InputsInitPipeItem {
typedef struct RedInputsInitPipeItem {
RedPipeItem base;
uint8_t modifiers;
} InputsInitPipeItem;
} RedInputsInitPipeItem;
static SpiceTimer *key_modifiers_timer;
@ -229,12 +229,12 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
return sif->get_leds(sin);
}
static RedPipeItem *inputs_key_modifiers_item_new(
static RedPipeItem *red_inputs_key_modifiers_item_new(
RedChannelClient *rcc, void *data, int num)
{
KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
RedKeyModifiersPipeItem *item = spice_malloc(sizeof(RedKeyModifiersPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_KEY_MODIFIERS);
item->modifiers = *(uint8_t *)data;
return &item->base;
}
@ -265,30 +265,30 @@ static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (base->type) {
case PIPE_ITEM_KEY_MODIFIERS:
case RED_PIPE_ITEM_KEY_MODIFIERS:
{
SpiceMsgInputsKeyModifiers key_modifiers;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_KEY_MODIFIERS, base);
key_modifiers.modifiers =
SPICE_CONTAINEROF(base, KeyModifiersPipeItem, base)->modifiers;
SPICE_CONTAINEROF(base, RedKeyModifiersPipeItem, base)->modifiers;
spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
break;
}
case PIPE_ITEM_INPUTS_INIT:
case RED_PIPE_ITEM_INPUTS_INIT:
{
SpiceMsgInputsInit inputs_init;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_INIT, base);
inputs_init.keyboard_modifiers =
SPICE_CONTAINEROF(base, InputsInitPipeItem, base)->modifiers;
SPICE_CONTAINEROF(base, RedInputsInitPipeItem, base)->modifiers;
spice_marshall_msg_inputs_init(m, &inputs_init);
break;
}
case PIPE_ITEM_MOUSE_MOTION_ACK:
case RED_PIPE_ITEM_MOUSE_MOTION_ACK:
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, base);
break;
case PIPE_ITEM_MIGRATE_DATA:
case RED_PIPE_ITEM_MIGRATE_DATA:
inputs_channel_send_migrate_data(rcc, m, base);
break;
default:
@ -339,7 +339,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (mouse && reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_SERVER) {
@ -357,7 +357,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT) {
@ -500,10 +500,10 @@ static void inputs_channel_on_disconnect(RedChannelClient *rcc)
static void inputs_pipe_add_init(RedChannelClient *rcc)
{
InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
RedInputsInitPipeItem *item = spice_malloc(sizeof(RedInputsInitPipeItem));
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_INPUTS_INIT);
item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
red_channel_client_pipe_add_push(rcc, &item->base);
}
@ -569,7 +569,7 @@ static void inputs_channel_push_keyboard_modifiers(InputsChannel *inputs, uint8_
return;
}
red_channel_pipes_new_add_push(&inputs->base,
inputs_key_modifiers_item_new, (void*)&modifiers);
red_inputs_key_modifiers_item_new, (void*)&modifiers);
}
void inputs_channel_on_keyboard_leds_change(InputsChannel *inputs, uint8_t leds)
@ -585,7 +585,7 @@ static void key_modifiers_sender(void *opaque)
static int inputs_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
{
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE_DATA);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MIGRATE_DATA);
return TRUE;
}
@ -612,7 +612,7 @@ static int inputs_channel_handle_migrate_data(RedChannelClient *rcc,
for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
}
return TRUE;
}

214
server/main-channel.c
View File

@ -60,54 +60,54 @@
static const uint8_t zero_page[ZERO_BUF_SIZE] = {0};
enum {
PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = PIPE_ITEM_TYPE_CHANNEL_BASE,
PIPE_ITEM_TYPE_MAIN_PING,
PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
PIPE_ITEM_TYPE_MAIN_INIT,
PIPE_ITEM_TYPE_MAIN_NOTIFY,
PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
PIPE_ITEM_TYPE_MAIN_NAME,
PIPE_ITEM_TYPE_MAIN_UUID,
PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_TYPE_MAIN_PING,
RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
RED_PIPE_ITEM_TYPE_MAIN_INIT,
RED_PIPE_ITEM_TYPE_MAIN_NOTIFY,
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
RED_PIPE_ITEM_TYPE_MAIN_NAME,
RED_PIPE_ITEM_TYPE_MAIN_UUID,
RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
};
typedef struct RefsPipeItem {
typedef struct RedRefsPipeItem {
RedPipeItem base;
int *refs;
} RefsPipeItem;
} RedRefsPipeItem;
typedef struct PingPipeItem {
typedef struct RedPingPipeItem {
RedPipeItem base;
int size;
} PingPipeItem;
} RedPingPipeItem;
typedef struct MouseModePipeItem {
typedef struct RedMouseModePipeItem {
RedPipeItem base;
int current_mode;
int is_client_mouse_allowed;
} MouseModePipeItem;
} RedMouseModePipeItem;
typedef struct TokensPipeItem {
typedef struct RedTokensPipeItem {
RedPipeItem base;
int tokens;
} TokensPipeItem;
} RedTokensPipeItem;
typedef struct AgentDataPipeItem {
typedef struct RedAgentDataPipeItem {
RedPipeItem base;
uint8_t* data;
size_t len;
spice_marshaller_item_free_func free_data;
void *opaque;
} AgentDataPipeItem;
} RedAgentDataPipeItem;
typedef struct InitPipeItem {
typedef struct RedInitPipeItem {
RedPipeItem base;
int connection_id;
int display_channels_hint;
@ -115,27 +115,27 @@ typedef struct InitPipeItem {
int is_client_mouse_allowed;
int multi_media_time;
int ram_hint;
} InitPipeItem;
} RedInitPipeItem;
typedef struct NamePipeItem {
typedef struct RedNamePipeItem {
RedPipeItem base;
SpiceMsgMainName msg;
} NamePipeItem;
} RedNamePipeItem;
typedef struct UuidPipeItem {
typedef struct RedUuidPipeItem {
RedPipeItem base;
SpiceMsgMainUuid msg;
} UuidPipeItem;
} RedUuidPipeItem;
typedef struct NotifyPipeItem {
typedef struct RedNotifyPipeItem {
RedPipeItem base;
char *msg;
} NotifyPipeItem;
} RedNotifyPipeItem;
typedef struct MultiMediaTimePipeItem {
typedef struct RedMultiMediaTimePipeItem {
RedPipeItem base;
int time;
} MultiMediaTimePipeItem;
} RedMultiMediaTimePipeItem;
struct MainChannelClient {
RedChannelClient base;
@ -223,29 +223,29 @@ typedef struct MainMouseModeItemInfo {
static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
{
MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
RedMouseModePipeItem *item = spice_malloc(sizeof(RedMouseModePipeItem));
MainMouseModeItemInfo *info = data;
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
item->current_mode = info->current_mode;
item->is_client_mouse_allowed = info->is_client_mouse_allowed;
return &item->base;
}
static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
static RedPipeItem *red_ping_item_new(MainChannelClient *mcc, int size)
{
PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
RedPingPipeItem *item = spice_malloc(sizeof(RedPingPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_PING);
item->size = size;
return &item->base;
}
static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
{
TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
RedTokensPipeItem *item = spice_malloc(sizeof(RedTokensPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
item->tokens = num_tokens;
return &item->base;
}
@ -254,9 +254,9 @@ static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* dat
spice_marshaller_item_free_func free_data,
void *opaque)
{
AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
RedAgentDataPipeItem *item = spice_malloc(sizeof(RedAgentDataPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
item->data = data;
item->len = len;
item->free_data = free_data;
@ -269,9 +269,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
RedInitPipeItem *item = spice_malloc(sizeof(RedInitPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_INIT);
item->connection_id = connection_id;
item->display_channels_hint = display_channels_hint;
item->current_mouse_mode = current_mouse_mode;
@ -283,9 +283,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
{
NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
RedNamePipeItem *item = spice_malloc(sizeof(RedNamePipeItem) + strlen(name) + 1);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NAME);
item->msg.name_len = strlen(name) + 1;
memcpy(&item->msg.name, name, item->msg.name_len);
@ -294,9 +294,9 @@ static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
{
UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
RedUuidPipeItem *item = spice_malloc(sizeof(RedUuidPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_UUID);
memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
return &item->base;
@ -304,10 +304,10 @@ static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uui
static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
{
NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
RedNotifyPipeItem *item = spice_malloc(sizeof(RedNotifyPipeItem));
const char *msg = data;
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NOTIFY);
item->msg = spice_strdup(msg);
return &item->base;
}
@ -315,10 +315,10 @@ static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int
static RedPipeItem *main_multi_media_time_item_new(
RedChannelClient *rcc, void *data, int num)
{
MultiMediaTimePipeItem *item, *info = data;
RedMultiMediaTimePipeItem *item, *info = data;
item = spice_malloc(sizeof(MultiMediaTimePipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item = spice_malloc(sizeof(RedMultiMediaTimePipeItem));
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item->time = info->time;
return &item->base;
}
@ -330,7 +330,7 @@ static void main_channel_push_channels(MainChannelClient *mcc)
"during migration");
return;
}
red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
}
static void main_channel_marshall_channels(RedChannelClient *rcc,
@ -354,14 +354,14 @@ int main_channel_client_push_ping(MainChannelClient *mcc, int size)
if (mcc == NULL) {
return FALSE;
}
item = main_ping_item_new(mcc, size);
item = red_ping_item_new(mcc, size);
red_channel_client_pipe_add_push(&mcc->base, item);
return TRUE;
}
static void main_channel_marshall_ping(RedChannelClient *rcc,
SpiceMarshaller *m,
PingPipeItem *item)
RedPingPipeItem *item)
{
MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
SpiceMsgPing ping;
@ -393,7 +393,7 @@ void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
SpiceMarshaller *m,
MouseModePipeItem *item)
RedMouseModePipeItem *item)
{
SpiceMsgMainMouseMode mouse_mode;
@ -409,7 +409,7 @@ static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
void main_channel_push_agent_connected(MainChannel *main_chan)
{
if (red_channel_test_remote_cap(&main_chan->base, SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
} else {
red_channel_pipes_add_empty_msg(&main_chan->base, SPICE_MSG_MAIN_AGENT_CONNECTED);
}
@ -428,7 +428,7 @@ static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
void main_channel_push_agent_disconnected(MainChannel *main_chan)
{
red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
}
static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
@ -450,7 +450,7 @@ void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_
}
static void main_channel_marshall_tokens(RedChannelClient *rcc,
SpiceMarshaller *m, TokensPipeItem *item)
SpiceMarshaller *m, RedTokensPipeItem *item)
{
SpiceMsgMainAgentTokens tokens;
@ -470,7 +470,7 @@ void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data,
static void main_channel_marshall_agent_data(RedChannelClient *rcc,
SpiceMarshaller *m,
AgentDataPipeItem *item)
RedAgentDataPipeItem *item)
{
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DATA, &item->base);
spice_marshaller_add_ref(m, item->data, item->len);
@ -478,7 +478,7 @@ static void main_channel_marshall_agent_data(RedChannelClient *rcc,
static void main_channel_push_migrate_data_item(MainChannel *main_chan)
{
red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
}
static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
@ -526,9 +526,9 @@ void main_channel_push_init(MainChannelClient *mcc,
static void main_channel_marshall_init(RedChannelClient *rcc,
SpiceMarshaller *m,
InitPipeItem *item)
RedInitPipeItem *item)
{
SpiceMsgMainInit init; // TODO - remove this copy, make InitPipeItem reuse SpiceMsgMainInit
SpiceMsgMainInit init; // TODO - remove this copy, make RedInitPipeItem reuse SpiceMsgMainInit
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_INIT, &item->base);
@ -577,7 +577,7 @@ void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
}
static void main_channel_marshall_notify(RedChannelClient *rcc,
SpiceMarshaller *m, NotifyPipeItem *item)
SpiceMarshaller *m, RedNotifyPipeItem *item)
{
SpiceMsgNotify notify;
@ -636,7 +636,7 @@ static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
{
MultiMediaTimePipeItem info = {
RedMultiMediaTimePipeItem info = {
.time = time,
};
@ -662,7 +662,7 @@ static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice
void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target)
{
main_channel_fill_mig_target(main_chan, mig_target);
red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
@ -690,7 +690,7 @@ static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelC
static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
SpiceMarshaller *m,
MultiMediaTimePipeItem *item)
RedMultiMediaTimePipeItem *item)
{
SpiceMsgMainMultiMediaTime time_mes;
@ -708,7 +708,7 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
* we ignore any pipe item that arrives before the INIT msg is sent.
* For seamless we don't send INIT, and the connection continues from the same place
* it stopped on the src side. */
if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != PIPE_ITEM_TYPE_MAIN_INIT) {
if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != RED_PIPE_ITEM_TYPE_MAIN_INIT) {
spice_printerr("Init msg for client %p was not sent yet "
"(client is probably during semi-seamless migration). Ignoring msg type %d",
rcc->client, base->type);
@ -716,65 +716,65 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
return;
}
switch (base->type) {
case PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
case RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
main_channel_marshall_channels(rcc, m, base);
break;
case PIPE_ITEM_TYPE_MAIN_PING:
case RED_PIPE_ITEM_TYPE_MAIN_PING:
main_channel_marshall_ping(rcc, m,
SPICE_CONTAINEROF(base, PingPipeItem, base));
SPICE_CONTAINEROF(base, RedPingPipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
case RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
{
MouseModePipeItem *item =
SPICE_CONTAINEROF(base, MouseModePipeItem, base);
RedMouseModePipeItem *item =
SPICE_CONTAINEROF(base, RedMouseModePipeItem, base);
main_channel_marshall_mouse_mode(rcc, m, item);
break;
}
case PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
main_channel_marshall_agent_disconnected(rcc, m, base);
break;
case PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
case RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
main_channel_marshall_tokens(rcc, m,
SPICE_CONTAINEROF(base, TokensPipeItem, base));
SPICE_CONTAINEROF(base, RedTokensPipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
main_channel_marshall_agent_data(rcc, m,
SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
SPICE_CONTAINEROF(base, RedAgentDataPipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
main_channel_marshall_migrate_data_item(rcc, m, base);
break;
case PIPE_ITEM_TYPE_MAIN_INIT:
case RED_PIPE_ITEM_TYPE_MAIN_INIT:
mcc->init_sent = TRUE;
main_channel_marshall_init(rcc, m,
SPICE_CONTAINEROF(base, InitPipeItem, base));
SPICE_CONTAINEROF(base, RedInitPipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_NOTIFY:
case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY:
main_channel_marshall_notify(rcc, m,
SPICE_CONTAINEROF(base, NotifyPipeItem, base));
SPICE_CONTAINEROF(base, RedNotifyPipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
main_channel_marshall_migrate_begin(m, rcc, base);
break;
case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
main_channel_marshall_migrate_begin_seamless(m, rcc, base);
break;
case PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
case RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
main_channel_marshall_multi_media_time(rcc, m,
SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
SPICE_CONTAINEROF(base, RedMultiMediaTimePipeItem, base));
break;
case PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
main_channel_marshall_migrate_switch(m, rcc, base);
break;
case PIPE_ITEM_TYPE_MAIN_NAME:
case RED_PIPE_ITEM_TYPE_MAIN_NAME:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_NAME, base);
spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, NamePipeItem, base)->msg);
spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, RedNamePipeItem, base)->msg);
break;
case PIPE_ITEM_TYPE_MAIN_UUID:
case RED_PIPE_ITEM_TYPE_MAIN_UUID:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_UUID, base);
spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, UuidPipeItem, base)->msg);
spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, RedUuidPipeItem, base)->msg);
break;
case PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
case RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
main_channel_marshall_agent_connected(m, rcc, base);
break;
default:
@ -787,14 +787,14 @@ static void main_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *base, int item_pushed)
{
switch (base->type) {
case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
AgentDataPipeItem *data = (AgentDataPipeItem *)base;
case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
RedAgentDataPipeItem *data = (RedAgentDataPipeItem *)base;
data->free_data(data->data, data->opaque);
break;
}
case PIPE_ITEM_TYPE_MAIN_NOTIFY: {
NotifyPipeItem *data = (NotifyPipeItem *)base;
case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY: {
RedNotifyPipeItem *data = (RedNotifyPipeItem *)base;
free(data->msg);
break;
}
@ -861,9 +861,9 @@ void main_channel_migrate_dst_complete(MainChannelClient *mcc)
if (mcc->mig_wait_prev_try_seamless) {
spice_assert(mcc->base.channel->clients_num == 1);
red_channel_client_pipe_add_type(&mcc->base,
PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
} else {
red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
}
mcc->mig_wait_connect = TRUE;
mcc->mig_wait_prev_complete = FALSE;
@ -1211,7 +1211,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = FALSE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@ -1238,7 +1238,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = TRUE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@ -1325,7 +1325,7 @@ int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
} else {
if (success) {
spice_printerr("client %p SWITCH_HOST", mcc->base.client);
red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
}
mcc->mig_connect_ok = FALSE;

34
server/red-channel.c
View File

@ -44,10 +44,10 @@
#include "main-dispatcher.h"
#include "utils.h"
typedef struct EmptyMsgPipeItem {
typedef struct RedEmptyMsgPipeItem {
RedPipeItem base;
int msg;
} EmptyMsgPipeItem;
} RedEmptyMsgPipeItem;
#define PING_TEST_TIMEOUT_MS (MSEC_PER_SEC * 15)
#define PING_TEST_IDLE_NET_TIMEOUT_MS (MSEC_PER_SEC / 10)
@ -477,7 +477,7 @@ static void red_channel_client_reset_send_data(RedChannelClient *rcc)
void red_channel_client_push_set_ack(RedChannelClient *rcc)
{
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SET_ACK);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SET_ACK);
}
static void red_channel_client_send_set_ack(RedChannelClient *rcc)
@ -512,7 +512,7 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc)
static void red_channel_client_send_empty_msg(RedChannelClient *rcc, RedPipeItem *base)
{
EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, EmptyMsgPipeItem, base);
RedEmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, RedEmptyMsgPipeItem, base);
red_channel_client_init_send_data(rcc, msg_pipe_item->msg, NULL);
red_channel_client_begin_send_message(rcc);
@ -562,16 +562,16 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
spice_assert(red_channel_client_no_item_being_sent(rcc));
red_channel_client_reset_send_data(rcc);
switch (item->type) {
case PIPE_ITEM_TYPE_SET_ACK:
case RED_PIPE_ITEM_TYPE_SET_ACK:
red_channel_client_send_set_ack(rcc);
break;
case PIPE_ITEM_TYPE_MIGRATE:
case RED_PIPE_ITEM_TYPE_MIGRATE:
red_channel_client_send_migrate(rcc);
break;
case PIPE_ITEM_TYPE_EMPTY_MSG:
case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
red_channel_client_send_empty_msg(rcc, item);
break;
case PIPE_ITEM_TYPE_PING:
case RED_PIPE_ITEM_TYPE_PING:
red_channel_client_send_ping(rcc);
break;
default:
@ -584,10 +584,10 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
static void red_channel_client_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
switch (item->type) {
case PIPE_ITEM_TYPE_SET_ACK:
case PIPE_ITEM_TYPE_EMPTY_MSG:
case PIPE_ITEM_TYPE_MIGRATE:
case PIPE_ITEM_TYPE_PING:
case RED_PIPE_ITEM_TYPE_SET_ACK:
case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
case RED_PIPE_ITEM_TYPE_MIGRATE:
case RED_PIPE_ITEM_TYPE_PING:
free(item);
break;
default:
@ -733,8 +733,8 @@ static void red_channel_client_push_ping(RedChannelClient *rcc)
rcc->latency_monitor.state = PING_STATE_WARMUP;
rcc->latency_monitor.warmup_was_sent = FALSE;
rcc->latency_monitor.id = rand();
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
}
static void red_channel_client_ping_timer(void *opaque)
@ -1013,7 +1013,7 @@ void red_channel_client_default_migrate(RedChannelClient *rcc)
rcc->channel->core->timer_remove(rcc->connectivity_monitor.timer);
rcc->connectivity_monitor.timer = NULL;
}
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MIGRATE);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_MIGRATE);
}
RedChannel *red_channel_create(int size,
@ -1737,9 +1737,9 @@ void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type)
void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
{
EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
RedEmptyMsgPipeItem *item = spice_new(RedEmptyMsgPipeItem, 1);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_EMPTY_MSG);
item->msg = msg_type;
red_channel_client_pipe_add(rcc, &item->base);
red_channel_client_push(rcc);

10
server/red-channel.h
View File

@ -140,12 +140,12 @@ typedef struct MainChannelClient MainChannelClient;
* but we keep the 100 first allocated for base channel approach.
* */
enum {
PIPE_ITEM_TYPE_SET_ACK=1,
PIPE_ITEM_TYPE_MIGRATE,
PIPE_ITEM_TYPE_EMPTY_MSG,
PIPE_ITEM_TYPE_PING,
RED_PIPE_ITEM_TYPE_SET_ACK=1,
RED_PIPE_ITEM_TYPE_MIGRATE,
RED_PIPE_ITEM_TYPE_EMPTY_MSG,
RED_PIPE_ITEM_TYPE_PING,
PIPE_ITEM_TYPE_CHANNEL_BASE=101,
RED_PIPE_ITEM_TYPE_CHANNEL_BASE=101,
};
typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannelClient *channel,

16
server/red-worker.h
View File

@ -50,27 +50,27 @@ typedef struct CommonGraphicsChannel {
#define COMMON_GRAPHICS_CHANNEL(Channel) ((CommonGraphicsChannel*)(Channel))
enum {
PIPE_ITEM_TYPE_VERB = PIPE_ITEM_TYPE_CHANNEL_BASE,
PIPE_ITEM_TYPE_INVAL_ONE,
RED_PIPE_ITEM_TYPE_VERB = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_TYPE_INVAL_ONE,
PIPE_ITEM_TYPE_COMMON_LAST
RED_PIPE_ITEM_TYPE_COMMON_LAST
};
typedef struct VerbItem {
typedef struct RedVerbItem {
RedPipeItem base;
uint16_t verb;
} VerbItem;
} RedVerbItem;
static inline void red_marshall_verb(RedChannelClient *rcc, VerbItem *item)
static inline void red_marshall_verb(RedChannelClient *rcc, RedVerbItem *item)
{
red_channel_client_init_send_data(rcc, item->verb, NULL);
}
static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
{
VerbItem *item = spice_new(VerbItem, 1);
RedVerbItem *item = spice_new(RedVerbItem, 1);
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_VERB);
item->verb = verb;
red_channel_client_pipe_add(rcc, &item->base);
}

35
server/reds.c
View File

@ -166,13 +166,13 @@ struct ChannelSecurityOptions {
ChannelSecurityOptions *next;
};
typedef struct VDIReadBuf {
typedef struct RedVDIReadBuf {
RedPipeItem parent;
RedCharDeviceVDIPort *dev;
int len;
uint8_t data[SPICE_AGENT_MAX_DATA_SIZE];
} VDIReadBuf;
} RedVDIReadBuf;
enum {
VDI_PORT_READ_STATE_READ_HEADER,
@ -196,7 +196,7 @@ struct RedCharDeviceVDIPortPrivate {
uint32_t message_receive_len;
uint8_t *receive_pos;
uint32_t receive_len;
VDIReadBuf *current_read_buf;
RedVDIReadBuf *current_read_buf;
AgentMsgFilter read_filter;
VDIChunkHeader vdi_chunk_header;
@ -261,8 +261,8 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode);
static uint32_t reds_qxl_ram_size(RedsState *reds);
static int calc_compression_level(RedsState *reds);
static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
static void vdi_port_read_buf_free(VDIReadBuf *buf);
static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
static void vdi_port_read_buf_free(RedVDIReadBuf *buf);
static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int id)
{
@ -703,13 +703,14 @@ static void reds_agent_remove(RedsState *reds)
static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
VDIReadBuf *buf = (VDIReadBuf *)opaque;
RedVDIReadBuf *buf = (RedVDIReadBuf *)opaque;
red_pipe_item_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf *buf, gboolean *error)
static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev,
RedVDIReadBuf *buf, gboolean *error)
{
int res;
@ -738,7 +739,7 @@ static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf
}
}
static void vdi_read_buf_init(VDIReadBuf *buf)
static void vdi_read_buf_init(RedVDIReadBuf *buf)
{
g_return_if_fail(buf != NULL);
/* Bogus pipe item type, we only need the RingItem and refcounting
@ -748,17 +749,17 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
(GDestroyNotify)vdi_port_read_buf_free);
}
static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
{
RingItem *item;
VDIReadBuf *buf;
RedVDIReadBuf *buf;
if (!(item = ring_get_head(&dev->priv->read_bufs))) {
return NULL;
}
ring_remove(item);
buf = SPICE_CONTAINEROF(item, VDIReadBuf, parent.link);
buf = SPICE_CONTAINEROF(item, RedVDIReadBuf, parent.link);
g_warn_if_fail(buf->parent.refcount == 0);
vdi_read_buf_init(buf);
@ -766,7 +767,7 @@ static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
return buf;
}
static void vdi_port_read_buf_free(VDIReadBuf *buf)
static void vdi_port_read_buf_free(RedVDIReadBuf *buf)
{
g_warn_if_fail(buf->parent.refcount == 0);
ring_add(&buf->dev->priv->read_bufs, (RingItem *)buf);
@ -788,7 +789,7 @@ static RedPipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *s
RedsState *reds;
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
SpiceCharDeviceInterface *sif;
VDIReadBuf *dispatch_buf;
RedVDIReadBuf *dispatch_buf;
int n;
g_object_get(dev, "spice-server", &reds, NULL);
@ -861,7 +862,7 @@ static void vdi_port_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
RedVDIReadBuf *agent_data_buf = (RedVDIReadBuf *)msg;
red_pipe_item_ref(agent_data_buf);
main_channel_client_push_agent_data(red_client_get_main(client),
@ -1201,7 +1202,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
if (agent_dev->priv->read_filter.msg_data_to_read ||
read_data_len > sizeof(VDAgentMessage)) { /* msg header has been read */
VDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
RedVDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
gboolean error = FALSE;
spice_debug("push partial read %u (msg first chunk? %d)", read_data_len,
@ -4290,7 +4291,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort *self)
self->priv->receive_len = sizeof(self->priv->vdi_chunk_header);
for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);
RedVDIReadBuf *buf = spice_new0(RedVDIReadBuf, 1);
vdi_read_buf_init(buf);
buf->dev = self;
g_warn_if_fail(!self->priv->agent_attached);
@ -4307,7 +4308,7 @@ red_char_device_vdi_port_finalize(GObject *object)
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(object);
free(dev->priv->mig_data);
/* FIXME: need to free the VDIReadBuf allocated previously */
/* FIXME: need to free the RedVDIReadBuf allocated previously */
}
static void

53
server/smartcard.c
View File

@ -77,24 +77,24 @@ struct RedCharDeviceSmartcardPrivate {
};
enum {
PIPE_ITEM_TYPE_ERROR = PIPE_ITEM_TYPE_CHANNEL_BASE,
PIPE_ITEM_TYPE_SMARTCARD_DATA,
PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
RED_PIPE_ITEM_TYPE_ERROR = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
};
typedef struct ErrorItem {
typedef struct RedErrorItem {
RedPipeItem base;
VSCMsgHeader vheader;
VSCMsgError error;
} ErrorItem;
} RedErrorItem;
typedef struct MsgItem {
typedef struct RedMsgItem {
RedPipeItem base;
VSCMsgHeader* vheader;
} MsgItem;
} RedMsgItem;
static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
typedef struct SmartCardChannel {
@ -113,7 +113,7 @@ static void smartcard_char_device_attach_client(
SpiceCharDeviceInstance *char_device, SmartCardChannelClient *scc);
static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_buf);
static MsgItem *smartcard_char_device_on_message_from_device(
static RedMsgItem *smartcard_char_device_on_message_from_device(
RedCharDeviceSmartcard *dev, VSCMsgHeader *header);
static RedCharDeviceSmartcard *smartcard_device_new(RedsState *reds, SpiceCharDeviceInstance *sin);
static void smartcard_init(RedsState *reds);
@ -140,7 +140,7 @@ static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
int actual_length;
while ((n = sif->read(sin, dev->priv->buf_pos, dev->priv->buf_size - dev->priv->buf_used)) > 0) {
MsgItem *msg_to_client;
RedMsgItem *msg_to_client;
dev->priv->buf_pos += n;
dev->priv->buf_used += n;
@ -190,8 +190,8 @@ static void smartcard_remove_client(RedClient *client, void *opaque)
red_channel_client_shutdown(&dev->priv->scc->base);
}
MsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
VSCMsgHeader *vheader)
RedMsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
VSCMsgHeader *vheader)
{
VSCMsgHeader *sent_header;
@ -441,7 +441,7 @@ static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *
static void smartcard_channel_send_error(
RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
{
ErrorItem* error_item = (ErrorItem*)item;
RedErrorItem* error_item = (RedErrorItem*)item;
smartcard_channel_send_data(rcc, m, item, &error_item->vheader);
}
@ -449,7 +449,7 @@ static void smartcard_channel_send_error(
static void smartcard_channel_send_msg(RedChannelClient *rcc,
SpiceMarshaller *m, RedPipeItem *item)
{
MsgItem* msg_item = (MsgItem*)item;
RedMsgItem* msg_item = (RedMsgItem*)item;
smartcard_channel_send_data(rcc, m, item, msg_item->vheader);
}
@ -488,13 +488,13 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
case PIPE_ITEM_TYPE_ERROR:
case RED_PIPE_ITEM_TYPE_ERROR:
smartcard_channel_send_error(rcc, m, item);
break;
case PIPE_ITEM_TYPE_SMARTCARD_DATA:
case RED_PIPE_ITEM_TYPE_SMARTCARD_DATA:
smartcard_channel_send_msg(rcc, m, item);
break;
case PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
case RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
smartcard_channel_send_migrate_data(rcc, m, item);
break;
default:
@ -508,7 +508,7 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item, int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
if (item->type == RED_PIPE_ITEM_TYPE_SMARTCARD_DATA) {
red_pipe_item_unref(item);
} else {
free(item);
@ -538,11 +538,11 @@ static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCErrorCode error)
{
ErrorItem *error_item = spice_new0(ErrorItem, 1);
RedErrorItem *error_item = spice_new0(RedErrorItem, 1);
red_pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
red_pipe_item_init(&error_item->base, RED_PIPE_ITEM_TYPE_ERROR);
error_item->base.type = PIPE_ITEM_TYPE_ERROR;
error_item->base.type = RED_PIPE_ITEM_TYPE_ERROR;
error_item->vheader.reader_id = reader_id;
error_item->vheader.type = VSC_Error;
error_item->vheader.length = sizeof(error_item->error);
@ -550,17 +550,18 @@ static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCE
smartcard_channel_client_pipe_add_push(rcc, &error_item->base);
}
static void smartcard_free_vsc_msg_item(MsgItem *item)
static void smartcard_free_vsc_msg_item(RedMsgItem *item)
{
free(item->vheader);
free(item);
}
static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader)
static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc,
VSCMsgHeader *vheader)
{
MsgItem *msg_item = spice_new0(MsgItem, 1);
RedMsgItem *msg_item = spice_new0(RedMsgItem, 1);
red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
red_pipe_item_init_full(&msg_item->base, RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
(GDestroyNotify)smartcard_free_vsc_msg_item);
msg_item->vheader = vheader;
return msg_item;
@ -635,7 +636,7 @@ static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_bu
static int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
return TRUE;
}

56
server/spicevmc.c
View File

@ -42,20 +42,20 @@
/* 64K should be enough for all but the largest writes + 32 bytes hdr */
#define BUF_SIZE (64 * 1024 + 32)
typedef struct SpiceVmcPipeItem {
typedef struct RedVmcPipeItem {
RedPipeItem base;
/* writes which don't fit this will get split, this is not a problem */
uint8_t buf[BUF_SIZE];
uint32_t buf_used;
} SpiceVmcPipeItem;
} RedVmcPipeItem;
typedef struct SpiceVmcState {
RedChannel channel; /* Must be the first item */
RedChannelClient *rcc;
RedCharDevice *chardev;
SpiceCharDeviceInstance *chardev_sin;
SpiceVmcPipeItem *pipe_item;
RedVmcPipeItem *pipe_item;
RedCharDeviceWriteBuffer *recv_from_client_buf;
uint8_t port_opened;
} SpiceVmcState;
@ -87,22 +87,22 @@ static RedCharDevice *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc, RED_TYPE_CHAR_DEVICE)
typedef struct PortInitPipeItem {
typedef struct RedPortInitPipeItem {
RedPipeItem base;
char* name;
uint8_t opened;
} PortInitPipeItem;
} RedPortInitPipeItem;
typedef struct PortEventPipeItem {
typedef struct RedPortEventPipeItem {
RedPipeItem base;
uint8_t event;
} PortEventPipeItem;
} RedPortEventPipeItem;
enum {
PIPE_ITEM_TYPE_SPICEVMC_DATA = PIPE_ITEM_TYPE_CHANNEL_BASE,
PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
PIPE_ITEM_TYPE_PORT_INIT,
PIPE_ITEM_TYPE_PORT_EVENT,
RED_PIPE_ITEM_TYPE_SPICEVMC_DATA = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
RED_PIPE_ITEM_TYPE_PORT_INIT,
RED_PIPE_ITEM_TYPE_PORT_EVENT,
};
static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
@ -110,7 +110,7 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
{
SpiceVmcState *state = opaque;
SpiceCharDeviceInterface *sif;
SpiceVmcPipeItem *msg_item;
RedVmcPipeItem *msg_item;
int n;
sif = spice_char_device_get_interface(sin);
@ -120,8 +120,8 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
}
if (!state->pipe_item) {
msg_item = spice_new0(SpiceVmcPipeItem, 1);
red_pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
msg_item = spice_new0(RedVmcPipeItem, 1);
red_pipe_item_init(&msg_item->base, RED_PIPE_ITEM_TYPE_SPICEVMC_DATA);
} else {
spice_assert(state->pipe_item->buf_used == 0);
msg_item = state->pipe_item;
@ -145,7 +145,7 @@ static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
void *opaque)
{
SpiceVmcState *state = opaque;
SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
RedVmcPipeItem *vmc_msg = (RedVmcPipeItem *)msg;
spice_assert(state->rcc->client == client);
red_pipe_item_ref(vmc_msg);
@ -156,9 +156,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
{
SpiceVmcState *state = SPICE_CONTAINEROF(rcc->channel, SpiceVmcState, channel);
SpiceCharDeviceInstance *sin = state->chardev_sin;
PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
RedPortInitPipeItem *item = spice_malloc(sizeof(RedPortInitPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_INIT);
item->name = strdup(sin->portname);
item->opened = state->port_opened;
red_channel_client_pipe_add_push(rcc, &item->base);
@ -166,9 +166,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
static void spicevmc_port_send_event(RedChannelClient *rcc, uint8_t event)
{
PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
RedPortEventPipeItem *item = spice_malloc(sizeof(RedPortEventPipeItem));
red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_EVENT);
item->event = event;
red_channel_client_pipe_add_push(rcc, &item->base);
}
@ -252,7 +252,7 @@ static SpiceVmcState *spicevmc_red_channel_client_get_state(RedChannelClient *rc
static int spicevmc_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
return TRUE;
}
@ -369,7 +369,7 @@ static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
RedVmcPipeItem *i = SPICE_CONTAINEROF(item, RedVmcPipeItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_SPICEVMC_DATA, item);
spice_marshaller_add_ref(m, i->buf, i->buf_used);
@ -393,7 +393,7 @@ static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
RedPortInitPipeItem *i = SPICE_CONTAINEROF(item, RedPortInitPipeItem, base);
SpiceMsgPortInit init;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_INIT, item);
@ -407,7 +407,7 @@ static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem, base);
RedPortEventPipeItem *i = SPICE_CONTAINEROF(item, RedPortEventPipeItem, base);
SpiceMsgPortEvent event;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_EVENT, item);
@ -421,16 +421,16 @@ static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
case PIPE_ITEM_TYPE_SPICEVMC_DATA:
case RED_PIPE_ITEM_TYPE_SPICEVMC_DATA:
spicevmc_red_channel_send_data(rcc, m, item);
break;
case PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
case RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
spicevmc_red_channel_send_migrate_data(rcc, m, item);
break;
case PIPE_ITEM_TYPE_PORT_INIT:
case RED_PIPE_ITEM_TYPE_PORT_INIT:
spicevmc_red_channel_send_port_init(rcc, m, item);
break;
case PIPE_ITEM_TYPE_PORT_EVENT:
case RED_PIPE_ITEM_TYPE_PORT_EVENT:
spicevmc_red_channel_send_port_event(rcc, m, item);
break;
default:
@ -445,7 +445,7 @@ static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item,
int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
if (item->type == RED_PIPE_ITEM_TYPE_SPICEVMC_DATA) {
red_pipe_item_unref(item);
} else {
free(item);

26
server/stream.c
View File

@ -133,7 +133,7 @@ void stream_agent_unref(DisplayChannel *display, StreamAgent *agent)
stream_unref(display, agent->stream);
}
void stream_clip_item_free(StreamClipItem *item)
void red_stream_clip_item_free(RedStreamClipItem *item)
{
g_return_if_fail(item != NULL);
DisplayChannel *display = DCC_TO_DC(item->stream_agent->dcc);
@ -145,11 +145,11 @@ void stream_clip_item_free(StreamClipItem *item)
free(item);
}
StreamClipItem *stream_clip_item_new(StreamAgent *agent)
RedStreamClipItem *red_stream_clip_item_new(StreamAgent *agent)
{
StreamClipItem *item = spice_new(StreamClipItem, 1);
red_pipe_item_init_full((RedPipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
(GDestroyNotify)stream_clip_item_free);
RedStreamClipItem *item = spice_new(RedStreamClipItem, 1);
red_pipe_item_init_full((RedPipeItem *)item, RED_PIPE_ITEM_TYPE_STREAM_CLIP,
(GDestroyNotify)red_stream_clip_item_free);
item->stream_agent = agent;
agent->stream->refs++;
@ -316,7 +316,7 @@ void detach_stream(DisplayChannel *display, Stream *stream,
static void before_reattach_stream(DisplayChannel *display,
Stream *stream, Drawable *new_frame)
{
DrawablePipeItem *dpi;
RedDrawablePipeItem *dpi;
DisplayChannelClient *dcc;
int index;
StreamAgent *agent;
@ -731,11 +731,11 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &agent->create_item);
if (red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT)) {
StreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
RedStreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
agent->report_id = rand();
red_pipe_item_init(&report_pipe_item->pipe_item,
PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &report_pipe_item->pipe_item);
}
@ -758,7 +758,7 @@ void stream_agent_stop(StreamAgent *agent)
}
}
static void upgrade_item_free(UpgradeItem *item)
static void red_upgrade_item_free(RedUpgradeItem *item)
{
g_return_if_fail(item != NULL);
g_return_if_fail(item->base.refcount != 0);
@ -792,7 +792,7 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
if (stream->current &&
region_contains(&stream->current->tree_item.base.rgn, &agent->vis_region)) {
RedChannelClient *rcc;
UpgradeItem *upgrade_item;
RedUpgradeItem *upgrade_item;
int n_rects;
/* (1) The caller should detach the drawable from the stream. This will
@ -807,9 +807,9 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
stream_id, stream->current->sized_stream != NULL);
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
upgrade_item = spice_new(UpgradeItem, 1);
red_pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
(GDestroyNotify)upgrade_item_free);
upgrade_item = spice_new(RedUpgradeItem, 1);
red_pipe_item_init_full(&upgrade_item->base, RED_PIPE_ITEM_TYPE_UPGRADE,
(GDestroyNotify)red_upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
n_rects = pixman_region32_n_rects(&upgrade_item->drawable->tree_item.base.rgn);

10
server/stream.h
View File

@ -46,10 +46,10 @@ typedef struct DisplayChannel DisplayChannel;
typedef struct Stream Stream;
typedef struct StreamActivateReportItem {
typedef struct RedStreamActivateReportItem {
RedPipeItem pipe_item;
uint32_t stream_id;
} StreamActivateReportItem;
} RedStreamActivateReportItem;
enum {
STREAM_FRAME_NONE,
@ -99,14 +99,14 @@ typedef struct StreamAgent {
#endif
} StreamAgent;
typedef struct StreamClipItem {
typedef struct RedStreamClipItem {
RedPipeItem base;
StreamAgent *stream_agent;
int clip_type;
SpiceClipRects *rects;
} StreamClipItem;
} RedStreamClipItem;
StreamClipItem * stream_clip_item_new (StreamAgent *agent);
RedStreamClipItem * red_stream_clip_item_new (StreamAgent *agent);
typedef struct ItemTrace {
red_time_t time;