diff options
| author | Jonathon Jongsma <jjongsma@redhat.com> | 2015-03-30 13:48:01 -0500 |
|---|---|---|
| committer | Jonathon Jongsma <jjongsma@redhat.com> | 2015-05-29 14:10:05 -0500 |
| commit | 559946489ec67739902c00466c38fcbb0c350940 (patch) | |
| tree | 39b2243eb9a8bbd79520c003e11593654ba7c249 | |
| parent | 7a35f4aa78a5a10827fdb2f47153c16d2400ca8b (diff) | |
gobject-ify RedChannelClient heirarchy
Convert the RedChannelClient heirarchy into GObjects. Since the existing
constructors could fail and return NULL, I inherited the base channel
client from GInitable, which introduces a dependency on gio.
40 files changed, 2894 insertions, 1593 deletions
diff --git a/configure.ac b/configure.ac index 5daefcd8..e98814f4 100644 --- a/configure.ac +++ b/configure.ac @@ -128,8 +128,8 @@ if test "x$enable_smartcard" = "xyes"; then fi -PKG_CHECK_MODULES([GLIB2], [glib-2.0 >= 2.22]) -AS_VAR_APPEND([SPICE_REQUIRES], [" glib-2.0 >= 2.22"]) +PKG_CHECK_MODULES([GLIB2], [glib-2.0 >= 2.22 gio-2.0 >= 2.22]) +AS_VAR_APPEND([SPICE_REQUIRES], [" glib-2.0 >= 2.22 gio-2.0 >= 2.22"]) PKG_CHECK_MODULES([GOBJECT2], [gobject-2.0 >= 2.22]) AS_VAR_APPEND([SPICE_REQUIRES], [" gobject-2.0 >= 2.22"]) diff --git a/server/Makefile.am b/server/Makefile.am index bc87adfa..7bfaec57 100644 --- a/server/Makefile.am +++ b/server/Makefile.am @@ -99,6 +99,8 @@ libspice_server_la_SOURCES = \ red-channel-client.c \ red-channel-client.h \ red-channel-client-private.h \ + dummy-channel-client.c \ + dummy-channel-client.h \ common.h \ dispatcher.c \ dispatcher.h \ @@ -167,6 +169,8 @@ if SUPPORT_SMARTCARD libspice_server_la_SOURCES += \ smartcard.c \ smartcard.h \ + smartcard-channel-client.c \ + smartcard-channel-client.h \ $(NULL) endif diff --git a/server/cache-item.c.template b/server/cache-item.c.template index 3c67996b..2a4d9838 100644 --- a/server/cache-item.c.template +++ b/server/cache-item.c.template @@ -48,12 +48,12 @@ static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id) { - CacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)]; + CacheItem *item = channel_client->priv->CACHE_NAME[CACHE_HASH_KEY(id)]; while (item) { if (item->id == id) { ring_remove(&item->u.cache_data.lru_link); - ring_add(&channel_client->VAR_NAME(lru), &item->u.cache_data.lru_link); + ring_add(&channel_client->priv->VAR_NAME(lru), &item->u.cache_data.lru_link); break; } item = item->u.cache_data.next; @@ -66,7 +66,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item) CacheItem **now; spice_assert(item); - now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)]; + now = &channel_client->priv->CACHE_NAME[CACHE_HASH_KEY(item->id)]; for (;;) { spice_assert(*now); if (*now == item) { @@ -76,11 +76,11 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item) now = &(*now)->u.cache_data.next; } ring_remove(&item->u.cache_data.lru_link); - channel_client->VAR_NAME(items)--; - channel_client->VAR_NAME(available) += item->size; + channel_client->priv->VAR_NAME(items)--; + channel_client->priv->VAR_NAME(available) += item->size; pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE); - red_channel_client_pipe_add_tail(&channel_client->common.base, &item->u.pipe_data); // for now + red_channel_client_pipe_add_tail(RED_CHANNEL_CLIENT(channel_client), &item->u.pipe_data); // for now } static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t size) @@ -90,21 +90,21 @@ static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t siz item = spice_new(CacheItem, 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)); + channel_client->priv->VAR_NAME(available) -= size; + while (channel_client->priv->VAR_NAME(available) < 0) { + CacheItem *tail = (CacheItem *)ring_get_tail(&channel_client->priv->VAR_NAME(lru)); if (!tail) { - channel_client->VAR_NAME(available) += size; + channel_client->priv->VAR_NAME(available) += size; free(item); return FALSE; } FUNC_NAME(remove)(channel_client, tail); } - ++channel_client->VAR_NAME(items); - item->u.cache_data.next = channel_client->CACHE_NAME[(key = CACHE_HASH_KEY(id))]; - channel_client->CACHE_NAME[key] = item; + ++channel_client->priv->VAR_NAME(items); + item->u.cache_data.next = channel_client->priv->CACHE_NAME[(key = CACHE_HASH_KEY(id))]; + channel_client->priv->CACHE_NAME[key] = item; ring_item_init(&item->u.cache_data.lru_link); - ring_add(&channel_client->VAR_NAME(lru), &item->u.cache_data.lru_link); + ring_add(&channel_client->priv->VAR_NAME(lru), &item->u.cache_data.lru_link); item->id = id; item->size = size; item->inval_type = CACHE_INVAL_TYPE; @@ -116,15 +116,15 @@ static void FUNC_NAME(reset)(CHANNELCLIENT *channel_client, long size) int i; for (i = 0; i < CACHE_HASH_SIZE; i++) { - while (channel_client->CACHE_NAME[i]) { - CacheItem *item = channel_client->CACHE_NAME[i]; - channel_client->CACHE_NAME[i] = item->u.cache_data.next; + while (channel_client->priv->CACHE_NAME[i]) { + CacheItem *item = channel_client->priv->CACHE_NAME[i]; + channel_client->priv->CACHE_NAME[i] = item->u.cache_data.next; free(item); } } - ring_init(&channel_client->VAR_NAME(lru)); - channel_client->VAR_NAME(available) = size; - channel_client->VAR_NAME(items) = 0; + ring_init(&channel_client->priv->VAR_NAME(lru)); + channel_client->priv->VAR_NAME(available) = size; + channel_client->priv->VAR_NAME(items) = 0; } diff --git a/server/common-worker-channel-client-private.h b/server/common-worker-channel-client-private.h index 631b0bc1..61718252 100644 --- a/server/common-worker-channel-client-private.h +++ b/server/common-worker-channel-client-private.h @@ -20,11 +20,10 @@ #include "common-worker-channel-client.h" #include "red-channel-client-private.h" -struct CommonWorkerChannelClient { - RedChannelClient base; - - uint32_t id; +struct _CommonWorkerChannelClientPrivate +{ RedWorker *worker; + gboolean migration_target; int is_low_bandwidth; }; diff --git a/server/common-worker-channel-client.c b/server/common-worker-channel-client.c index f16ac8f6..99c8fbc9 100644 --- a/server/common-worker-channel-client.c +++ b/server/common-worker-channel-client.c @@ -20,52 +20,138 @@ #include "red-worker.h" #include "red-channel-client.h" -void common_worker_channel_client_set_low_bandwidth(CommonWorkerChannelClient *self, - gboolean low_bandwidth) +G_DEFINE_TYPE (CommonWorkerChannelClient, common_worker_channel_client, RED_TYPE_CHANNEL_CLIENT) + +#define WORKER_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_COMMON_WORKER_CHANNEL_CLIENT, CommonWorkerChannelClientPrivate)) + +enum +{ + PROP0, + PROP_WORKER, + PROP_MIGRATION_TARGET +}; + +static void common_worker_channel_client_get_property(GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) { - self->is_low_bandwidth = low_bandwidth; + CommonWorkerChannelClient *self = COMMON_WORKER_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_WORKER: + g_value_set_pointer(value, self->priv->worker); + break; + case PROP_MIGRATION_TARGET: + g_value_set_boolean(value, self->priv->migration_target); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } } -gboolean common_worker_channel_client_is_low_bandwidth(CommonWorkerChannelClient *self) +static void common_worker_channel_client_set_property(GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) { - return self->is_low_bandwidth; + CommonWorkerChannelClient *self = COMMON_WORKER_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_WORKER: + self->priv->worker = g_value_get_pointer(value); + break; + case PROP_MIGRATION_TARGET: + self->priv->migration_target = g_value_get_boolean(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } } -RedWorker* common_worker_channel_get_worker(CommonWorkerChannelClient *self) +static void common_worker_channel_client_dispose(GObject *object) { - return self->worker; + G_OBJECT_CLASS(common_worker_channel_client_parent_class)->dispose(object); } -void common_worker_channel_set_worker(CommonWorkerChannelClient *self, RedWorker* worker) +static void common_worker_channel_client_finalize(GObject *object) { - self->worker = worker; + G_OBJECT_CLASS(common_worker_channel_client_parent_class)->finalize(object); } -CommonWorkerChannelClient *common_worker_channel_client_new(CommonWorkerChannel *common, - int size, - RedClient *client, - RedsStream *stream, - int mig_target, - int monitor_latency, - uint32_t *common_caps, - int num_common_caps, - uint32_t *caps, - int num_caps) +static void common_worker_channel_client_constructed(GObject *object) { - RedChannelClient *rcc = - red_channel_client_create(size, RED_CHANNEL(common), client, stream, monitor_latency, - num_common_caps, common_caps, num_caps, caps); - if (!rcc) { - return NULL; - } - CommonWorkerChannelClient *common_cc = (CommonWorkerChannelClient*)rcc; - common_cc->worker = common->worker; - common_cc->id = red_worker_get_qxl(common->worker)->id; - common->during_target_migrate = mig_target; + CommonWorkerChannelClient *self = COMMON_WORKER_CHANNEL_CLIENT(object); + CommonWorkerChannel *channel = COMMON_WORKER_CHANNEL(red_channel_client_get_channel(RED_CHANNEL_CLIENT(self))); + + G_OBJECT_CLASS(common_worker_channel_client_parent_class)->constructed(object); // TODO: move wide/narrow ack setting to red_channel. - red_channel_client_ack_set_client_window(rcc, - common_cc->is_low_bandwidth ? - WIDE_CLIENT_ACK_WINDOW : NARROW_CLIENT_ACK_WINDOW); - return common_cc; + // FIXME: nothing has set is_low_bandwidth yet... + red_channel_client_ack_set_client_window(RED_CHANNEL_CLIENT(self), + self->priv->is_low_bandwidth ? + WIDE_CLIENT_ACK_WINDOW : NARROW_CLIENT_ACK_WINDOW); + + channel->during_target_migrate = self->priv->migration_target; +} + +static void common_worker_channel_client_class_init(CommonWorkerChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof (CommonWorkerChannelClientPrivate)); + + object_class->get_property = common_worker_channel_client_get_property; + object_class->set_property = common_worker_channel_client_set_property; + object_class->dispose = common_worker_channel_client_dispose; + object_class->finalize = common_worker_channel_client_finalize; + object_class->constructed = common_worker_channel_client_constructed; + + g_object_class_install_property(object_class, + PROP_WORKER, + g_param_spec_pointer("worker", + "worker", + "worker", + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(object_class, + PROP_MIGRATION_TARGET, + g_param_spec_boolean("migration-target", + "migration target", + "Whether this is a migration target", + FALSE, + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); +} + +static void common_worker_channel_client_init(CommonWorkerChannelClient *self) +{ + self->priv = WORKER_CHANNEL_CLIENT_PRIVATE(self); +} + +void common_worker_channel_client_set_low_bandwidth(CommonWorkerChannelClient *self, + gboolean low_bandwidth) +{ + self->priv->is_low_bandwidth = low_bandwidth; +} + +gboolean common_worker_channel_client_is_low_bandwidth(CommonWorkerChannelClient *self) +{ + return self->priv->is_low_bandwidth; +} + +RedWorker* common_worker_channel_client_get_worker(CommonWorkerChannelClient *self) +{ + return self->priv->worker; +} + +uint32_t common_worker_channel_client_get_id(CommonWorkerChannelClient *self) +{ + QXLInstance* qxl = red_worker_get_qxl(self->priv->worker); + return qxl->id; } diff --git a/server/common-worker-channel-client.h b/server/common-worker-channel-client.h index abc0fe45..1bac0f98 100644 --- a/server/common-worker-channel-client.h +++ b/server/common-worker-channel-client.h @@ -17,9 +17,38 @@ #ifndef _COMMON_WORKER_CHANNEL_CLIENT_H #define _COMMON_WORKER_CHANNEL_CLIENT_H +#include <glib-object.h> #include "common.h" +#include "red-channel-client.h" + +G_BEGIN_DECLS + +#define TYPE_COMMON_WORKER_CHANNEL_CLIENT common_worker_channel_client_get_type() + +#define COMMON_WORKER_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_COMMON_WORKER_CHANNEL_CLIENT, CommonWorkerChannelClient)) +#define COMMON_WORKER_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_COMMON_WORKER_CHANNEL_CLIENT, CommonWorkerChannelClientClass)) +#define IS_COMMON_WORKER_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_COMMON_WORKER_CHANNEL_CLIENT)) +#define IS_COMMON_WORKER_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_COMMON_WORKER_CHANNEL_CLIENT)) +#define COMMON_WORKER_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_COMMON_WORKER_CHANNEL_CLIENT, CommonWorkerChannelClientClass)) + +typedef struct _CommonWorkerChannelClient CommonWorkerChannelClient; +typedef struct _CommonWorkerChannelClientClass CommonWorkerChannelClientClass; +typedef struct _CommonWorkerChannelClientPrivate CommonWorkerChannelClientPrivate; + +struct _CommonWorkerChannelClient +{ + RedChannelClient parent; + + CommonWorkerChannelClientPrivate *priv; +}; + +struct _CommonWorkerChannelClientClass +{ + RedChannelClientClass parent_class; +}; + +GType common_worker_channel_client_get_type(void) G_GNUC_CONST; -typedef struct CommonWorkerChannelClient CommonWorkerChannelClient; typedef struct CommonWorkerChannel CommonWorkerChannel; typedef struct RedWorker RedWorker; typedef struct RedClient RedClient; @@ -28,17 +57,9 @@ typedef struct RedsStream RedsStream; void common_worker_channel_client_set_low_bandwidth(CommonWorkerChannelClient *self, gboolean low_bandwidth); gboolean common_worker_channel_client_is_low_bandwidth(CommonWorkerChannelClient *self); -RedWorker* common_worker_channel_get_worker(CommonWorkerChannelClient *self); - -CommonWorkerChannelClient *common_worker_channel_client_new(CommonWorkerChannel *common, - int size, - RedClient *client, - RedsStream *stream, - int mig_target, - int monitor_latency, - uint32_t *common_caps, - int num_common_caps, - uint32_t *caps, - int num_caps); +RedWorker* common_worker_channel_client_get_worker(CommonWorkerChannelClient *self); +uint32_t common_worker_channel_client_get_id(CommonWorkerChannelClient *self); + +G_END_DECLS #endif /* _COMMON_WORKER_CHANNEL_CLIENT_H */ diff --git a/server/cursor-channel-client.c b/server/cursor-channel-client.c index 042571e6..18584440 100644 --- a/server/cursor-channel-client.c +++ b/server/cursor-channel-client.c @@ -34,17 +34,43 @@ enum { PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE, }; -struct _CursorChannelClient { - CommonWorkerChannelClient common; +G_DEFINE_TYPE(CursorChannelClient, cursor_channel_client, TYPE_COMMON_WORKER_CHANNEL_CLIENT) +#define CURSOR_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_CURSOR_CHANNEL_CLIENT, CursorChannelClientPrivate)) + +struct _CursorChannelClientPrivate +{ CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE]; Ring cursor_cache_lru; long cursor_cache_available; uint32_t cursor_cache_items; }; +static void cursor_channel_client_constructed(GObject *object) +{ + G_OBJECT_CLASS(cursor_channel_client_parent_class)->constructed(object); + + red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(object)); + red_channel_client_push_set_ack(RED_CHANNEL_CLIENT(object)); +} + +static void +cursor_channel_client_class_init(CursorChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(CursorChannelClientPrivate)); -#define RCC_TO_CCC(rcc) ((CursorChannelClient*)rcc) + object_class->constructed = cursor_channel_client_constructed; +} + +static void +cursor_channel_client_init(CursorChannelClient *self) +{ + self->priv = CURSOR_CHANNEL_CLIENT_PRIVATE(self); + ring_init(&self->priv->cursor_cache_lru); + self->priv->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE; +} #define CLIENT_CURSOR_CACHE #include "cache-item.c.template" @@ -56,7 +82,7 @@ static int _cursor_count = 0; void cursor_channel_client_reset_cursor_cache(RedChannelClient *rcc) { - red_cursor_cache_reset(RCC_TO_CCC(rcc), CLIENT_CURSOR_CACHE_SIZE); + red_cursor_cache_reset(CURSOR_CHANNEL_CLIENT(rcc), CLIENT_CURSOR_CACHE_SIZE); } void cursor_channel_client_on_disconnect(RedChannelClient *rcc) @@ -83,32 +109,36 @@ CursorChannelClient* cursor_channel_client_new(CursorChannel *cursor, RedClient uint32_t *common_caps, int num_common_caps, uint32_t *caps, int num_caps) { - spice_return_val_if_fail(cursor, NULL); - spice_return_val_if_fail(client, NULL); - spice_return_val_if_fail(stream, NULL); - spice_return_val_if_fail(!num_common_caps || common_caps, NULL); - spice_return_val_if_fail(!num_caps || caps, NULL); - - CursorChannelClient *ccc = - (CursorChannelClient*)common_worker_channel_client_new((CommonWorkerChannel*)cursor, - sizeof(CursorChannelClient), - client, stream, - mig_target, - FALSE, - common_caps, - num_common_caps, - caps, - num_caps); - spice_return_val_if_fail(ccc != NULL, NULL); - - ring_init(&ccc->cursor_cache_lru); - ccc->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE; - - RedChannelClient *rcc = RED_CHANNEL_CLIENT(ccc); - red_channel_client_ack_zero_messages_window(rcc); - red_channel_client_push_set_ack(rcc); - - return ccc; + CursorChannelClient *rcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); + } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + + rcc = g_initable_new(TYPE_CURSOR_CHANNEL_CLIENT, + NULL, NULL, + "channel", cursor, + "client", client, + "stream", stream, + "migration-target", mig_target, + "monitor-latency", FALSE, + "common-caps", common_caps_array, + "caps", caps_array, + "worker", COMMON_WORKER_CHANNEL(cursor)->worker, + NULL); + + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); + + return rcc; } CacheItem* cursor_channel_client_cache_find(CursorChannelClient *ccc, uint64_t id) diff --git a/server/cursor-channel-client.h b/server/cursor-channel-client.h index 5f27b513..574322e1 100644 --- a/server/cursor-channel-client.h +++ b/server/cursor-channel-client.h @@ -18,15 +18,40 @@ #ifndef CURSOR_CHANNEL_CLIENT_H_ # define CURSOR_CHANNEL_CLIENT_H_ +#include <glib-object.h> #include "cache-item.h" #include "common.h" #include "red-channel.h" #include "reds-stream.h" -typedef struct _CursorChannel CursorChannel; +G_BEGIN_DECLS + +#define TYPE_CURSOR_CHANNEL_CLIENT cursor_channel_client_get_type() + +#define CURSOR_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_CURSOR_CHANNEL_CLIENT, CursorChannelClient)) +#define CURSOR_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_CURSOR_CHANNEL_CLIENT, CursorChannelClientClass)) +#define IS_CURSOR_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_CURSOR_CHANNEL_CLIENT)) +#define IS_CURSOR_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_CURSOR_CHANNEL_CLIENT)) +#define CURSOR_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_CURSOR_CHANNEL_CLIENT, CursorChannelClientClass)) + typedef struct _CursorChannelClient CursorChannelClient; +typedef struct _CursorChannelClientClass CursorChannelClientClass; +typedef struct _CursorChannelClientPrivate CursorChannelClientPrivate; +typedef struct _CursorChannel CursorChannel; + +struct _CursorChannelClient +{ + CommonWorkerChannelClient parent; + + CursorChannelClientPrivate *priv; +}; + +struct _CursorChannelClientClass +{ + CommonWorkerChannelClientClass parent_class; +}; -#define CURSOR_CHANNEL_CLIENT(Client) ((CursorChannelClient*)(Client)) +GType cursor_channel_client_get_type(void) G_GNUC_CONST; CursorChannelClient* cursor_channel_client_new(CursorChannel *cursor, RedClient *client, @@ -34,11 +59,14 @@ CursorChannelClient* cursor_channel_client_new(CursorChannel *cursor, int mig_target, uint32_t *common_caps, int num_common_caps, - uint32_t *caps, int num_caps); + uint32_t *caps, + int num_caps); void cursor_channel_client_migrate(CursorChannelClient* client); void cursor_channel_client_reset_cursor_cache(RedChannelClient *rcc); void cursor_channel_client_on_disconnect(RedChannelClient *rcc); -CacheItem* cursor_channel_client_cache_find(CursorChannelClient *ccc, uint64_t id); -int cursor_channel_client_cache_add(CursorChannelClient *ccc, uint64_t id, size_t size); +CacheItem* cursor_channel_client_cache_find(CursorChannelClient *ccc, + uint64_t id); +int cursor_channel_client_cache_add(CursorChannelClient *ccc, uint64_t + id, size_t size); #endif /* CURSOR_CHANNEL_CLIENT_H_ */ diff --git a/server/cursor-channel.c b/server/cursor-channel.c index e83cf9f6..abed6b2a 100644 --- a/server/cursor-channel.c +++ b/server/cursor-channel.c @@ -203,7 +203,7 @@ static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_ // TODO: share code between before/after_push since most of the items need the same // release -static void cursor_channel_client_release_item_before_push(CursorChannelClient *ccc, +static void cursor_channel_release_item_before_push(CursorChannelClient *ccc, PipeItem *item) { switch (item->type) { @@ -223,7 +223,7 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient * } } -static void cursor_channel_client_release_item_after_push(CursorChannelClient *ccc, +static void cursor_channel_release_item_after_push(CursorChannelClient *ccc, PipeItem *item) { switch (item->type) { @@ -241,12 +241,12 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas PipeItem *pipe_item) { CursorChannel *cursor; - CursorChannelClient *ccc = (CursorChannelClient*)rcc; + CursorChannelClient *ccc = CURSOR_CHANNEL_CLIENT(rcc); SpiceMsgCursorInit msg; AddBufInfo info; spice_return_if_fail(rcc); - cursor = (CursorChannel*)rcc->channel; + cursor = (CursorChannel*)red_channel_client_get_channel(rcc); red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INIT, NULL); msg.visible = cursor->cursor_visible; @@ -262,8 +262,9 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas static void cursor_marshall(RedChannelClient *rcc, SpiceMarshaller *m, CursorPipeItem *cursor_pipe_item) { - CursorChannel *cursor = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base); - CursorChannelClient *ccc = (CursorChannelClient*)rcc; + CursorChannel *cursor = SPICE_CONTAINEROF(red_channel_client_get_channel(rcc), + CursorChannel, common.base); + CursorChannelClient *ccc = CURSOR_CHANNEL_CLIENT(rcc); CursorItem *item = cursor_pipe_item->cursor_item; PipeItem *pipe_item = &cursor_pipe_item->base; RedCursorCmd *cmd; @@ -326,7 +327,7 @@ static inline void red_marshall_inval(RedChannelClient *rcc, static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item) { SpiceMarshaller *m = red_channel_client_get_marshaller(rcc); - CursorChannelClient *ccc = (CursorChannelClient*)rcc; + CursorChannelClient *ccc = CURSOR_CHANNEL_CLIENT(rcc); switch (pipe_item->type) { case PIPE_ITEM_TYPE_CURSOR: @@ -350,7 +351,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item) spice_error("invalid pipe item type"); } - cursor_channel_client_release_item_before_push(ccc, pipe_item); + cursor_channel_release_item_before_push(ccc, pipe_item); red_channel_client_begin_send_message(rcc); } @@ -376,15 +377,15 @@ static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item) static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed) { - CursorChannelClient *ccc = (CursorChannelClient*)rcc; + CursorChannelClient *ccc = CURSOR_CHANNEL_CLIENT(rcc); spice_return_if_fail(item); if (item_pushed) { - cursor_channel_client_release_item_after_push(ccc, item); + cursor_channel_release_item_after_push(ccc, item); } else { spice_debug("not pushed (%d)", item->type); - cursor_channel_client_release_item_before_push(ccc, item); + cursor_channel_release_item_before_push(ccc, item); } } diff --git a/server/dcc-encoders.c b/server/dcc-encoders.c index a4a316a9..84a7f39c 100644 --- a/server/dcc-encoders.c +++ b/server/dcc-encoders.c @@ -280,30 +280,30 @@ static int zlib_usr_more_input(ZlibEncoderUsrContext *usr, uint8_t** input) static void dcc_init_quic(DisplayChannelClient *dcc) { - dcc->quic_data.usr.error = quic_usr_error; - dcc->quic_data.usr.warn = quic_usr_warn; - dcc->quic_data.usr.info = quic_usr_warn; - dcc->quic_data.usr.malloc = quic_usr_malloc; - dcc->quic_data.usr.free = quic_usr_free; - dcc->quic_data.usr.more_space = quic_usr_more_space; - dcc->quic_data.usr.more_lines = quic_usr_more_lines; + dcc->priv->quic_data.usr.error = quic_usr_error; + dcc->priv->quic_data.usr.warn = quic_usr_warn; + dcc->priv->quic_data.usr.info = quic_usr_warn; + dcc->priv->quic_data.usr.malloc = quic_usr_malloc; + dcc->priv->quic_data.usr.free = quic_usr_free; + dcc->priv->quic_data.usr.more_space = quic_usr_more_space; + dcc->priv->quic_data.usr.more_lines = quic_usr_more_lines; - dcc->quic = quic_create(&dcc->quic_data.usr); - spice_warn_if_fail(dcc->quic); + dcc->priv->quic = quic_create(&dcc->priv->quic_data.usr); + spice_warn_if_fail(dcc->priv->quic); } static void dcc_init_lz(DisplayChannelClient *dcc) { - dcc->lz_data.usr.error = lz_usr_error; - dcc->lz_data.usr.warn = lz_usr_warn; - dcc->lz_data.usr.info = lz_usr_warn; - dcc->lz_data.usr.malloc = lz_usr_malloc; - dcc->lz_data.usr.free = lz_usr_free; - dcc->lz_data.usr.more_space = lz_usr_more_space; - dcc->lz_data.usr.more_lines = lz_usr_more_lines; + dcc->priv->lz_data.usr.error = lz_usr_error; + dcc->priv->lz_data.usr.warn = lz_usr_warn; + dcc->priv->lz_data.usr.info = lz_usr_warn; + dcc->priv->lz_data.usr.malloc = lz_usr_malloc; + dcc->priv->lz_data.usr.free = lz_usr_free; + dcc->priv->lz_data.usr.more_space = lz_usr_more_space; + dcc->priv->lz_data.usr.more_lines = lz_usr_more_lines; - dcc->lz = lz_create(&dcc->lz_data.usr); - spice_warn_if_fail(dcc->lz); + dcc->priv->lz = lz_create(&dcc->priv->lz_data.usr); + spice_warn_if_fail(dcc->priv->lz); } static void glz_usr_free_image(GlzEncoderUsrContext *usr, GlzUsrImageContext *image) @@ -311,7 +311,8 @@ static void glz_usr_free_image(GlzEncoderUsrContext *usr, GlzUsrImageContext *im GlzData *lz_data = (GlzData *)usr; GlzDrawableInstanceItem *glz_drawable_instance = (GlzDrawableInstanceItem *)image; DisplayChannelClient *drawable_cc = glz_drawable_instance->glz_drawable->dcc; - DisplayChannelClient *this_cc = SPICE_CONTAINEROF(lz_data, DisplayChannelClient, glz_data); + DisplayChannelClientPrivate *ccp = SPICE_CONTAINEROF(lz_data, DisplayChannelClientPrivate, glz_data); + DisplayChannelClient *this_cc = SPICE_CONTAINEROF(ccp, DisplayChannelClient, priv); if (this_cc == drawable_cc) { dcc_free_glz_drawable_instance(drawable_cc, glz_drawable_instance); } else { @@ -322,53 +323,53 @@ static void glz_usr_free_image(GlzEncoderUsrContext *usr, GlzUsrImageContext *im * called from any DisplayChannelClient thread, hence the need for * this check. */ - pthread_mutex_lock(&drawable_cc->glz_drawables_inst_to_free_lock); + pthread_mutex_lock(&drawable_cc->priv->glz_drawables_inst_to_free_lock); ring_add_before(&glz_drawable_instance->free_link, - &drawable_cc->glz_drawables_inst_to_free); - pthread_mutex_unlock(&drawable_cc->glz_drawables_inst_to_free_lock); + &drawable_cc->priv->glz_drawables_inst_to_free); + pthread_mutex_unlock(&drawable_cc->priv->glz_drawables_inst_to_free_lock); } } static void dcc_init_glz_data(DisplayChannelClient *dcc) { - dcc->glz_data.usr.error = glz_usr_error; - dcc->glz_data.usr.warn = glz_usr_warn; - dcc->glz_data.usr.info = glz_usr_warn; - dcc->glz_data.usr.malloc = glz_usr_malloc; - dcc->glz_data.usr.free = glz_usr_free; - dcc->glz_data.usr.more_space = glz_usr_more_space; - dcc->glz_data.usr.more_lines = glz_usr_more_lines; - dcc->glz_data.usr.free_image = glz_usr_free_image; + dcc->priv->glz_data.usr.error = glz_usr_error; + dcc->priv->glz_data.usr.warn = glz_usr_warn; + dcc->priv->glz_data.usr.info = glz_usr_warn; + dcc->priv->glz_data.usr.malloc = glz_usr_malloc; + dcc->priv->glz_data.usr.free = glz_usr_free; + dcc->priv->glz_data.usr.more_space = glz_usr_more_space; + dcc->priv->glz_data.usr.more_lines = glz_usr_more_lines; + dcc->priv->glz_data.usr.free_image = glz_usr_free_image; } static void dcc_init_jpeg(DisplayChannelClient *dcc) { - dcc->jpeg_data.usr.more_space = jpeg_usr_more_space; - dcc->jpeg_data.usr.more_lines = jpeg_usr_more_lines; + dcc->priv->jpeg_data.usr.more_space = jpeg_usr_more_space; + dcc->priv->jpeg_data.usr.more_lines = jpeg_usr_more_lines; - dcc->jpeg = jpeg_encoder_create(&dcc->jpeg_data.usr); - spice_warn_if_fail(dcc->jpeg); + dcc->priv->jpeg = jpeg_encoder_create(&dcc->priv->jpeg_data.usr); + spice_warn_if_fail(dcc->priv->jpeg); } #ifdef USE_LZ4 static inline void dcc_init_lz4(DisplayChannelClient *dcc) { - dcc->lz4_data.usr.more_space = lz4_usr_more_space; - dcc->lz4_data.usr.more_lines = lz4_usr_more_lines; + dcc->priv->lz4_data.usr.more_space = lz4_usr_more_space; + dcc->priv->lz4_data.usr.more_lines = lz4_usr_more_lines; - dcc->lz4 = lz4_encoder_create(&dcc->lz4_data.usr); + dcc->priv->lz4 = lz4_encoder_create(&dcc->priv->lz4_data.usr); - spice_warn_if_fail(dcc->lz4) { + spice_warn_if_fail(dcc->priv->lz4) { } #endif static void dcc_init_zlib(DisplayChannelClient *dcc) { - dcc->zlib_data.usr.more_space = zlib_usr_more_space; - dcc->zlib_data.usr.more_input = zlib_usr_more_input; + dcc->priv->zlib_data.usr.more_space = zlib_usr_more_space; + dcc->priv->zlib_data.usr.more_input = zlib_usr_more_input; - dcc->zlib = zlib_encoder_create(&dcc->zlib_data.usr, ZLIB_DEFAULT_COMPRESSION_LEVEL); - spice_warn_if_fail(dcc->zlib); + dcc->priv->zlib = zlib_encoder_create(&dcc->priv->zlib_data.usr, ZLIB_DEFAULT_COMPRESSION_LEVEL); + spice_warn_if_fail(dcc->priv->zlib); } void dcc_encoders_init(DisplayChannelClient *dcc) @@ -383,7 +384,7 @@ void dcc_encoders_init(DisplayChannelClient *dcc) dcc_init_zlib(dcc); // todo: tune level according to bandwidth - dcc->zlib_level = ZLIB_DEFAULT_COMPRESSION_LEVEL; + dcc->priv->zlib_level = ZLIB_DEFAULT_COMPRESSION_LEVEL; } void marshaller_add_compressed(SpiceMarshaller *m, @@ -440,7 +441,7 @@ void dcc_free_glz_drawable_instance(DisplayChannelClient *dcc, } red_drawable_unref(worker, glz_drawable->red_drawable, glz_drawable->group_id); - dcc->glz_drawable_count--; + dcc->priv->glz_drawable_count--; if (ring_item_is_linked(&glz_drawable->link)) { ring_remove(&glz_drawable->link); } @@ -469,9 +470,9 @@ void dcc_free_glz_drawable(DisplayChannelClient *dcc, RedGlzDrawable *drawable) glz_link); if (!ring_item_is_linked(&instance->free_link)) { // the instance didn't get out from window yet - glz_enc_dictionary_remove_image(dcc->glz_dict->dict, + glz_enc_dictionary_remove_image(dcc->priv->glz_dict->dict, instance->context, - &dcc->glz_data.usr); + &dcc->priv->glz_data.usr); } dcc_free_glz_drawable_instance(dcc, instance); @@ -494,10 +495,10 @@ int dcc_free_some_independent_glz_drawables(DisplayChannelClient *dcc) if (!dcc) { return 0; } - ring_link = ring_get_head(&dcc->glz_drawables); + ring_link = ring_get_head(&dcc->priv->glz_drawables); while ((n < RED_RELEASE_BUNCH_SIZE) && (ring_link != NULL)) { RedGlzDrawable *glz_drawable = SPICE_CONTAINEROF(ring_link, RedGlzDrawable, link); - ring_link = ring_next(&dcc->glz_drawables, ring_link); + ring_link = ring_next(&dcc->priv->glz_drawables, ring_link); if (!glz_drawable->drawable) { dcc_free_glz_drawable(dcc, glz_drawable); n++; @@ -510,17 +511,17 @@ void dcc_free_glz_drawables_to_free(DisplayChannelClient* dcc) { RingItem *ring_link; - if (!dcc->glz_dict) { + if (!dcc->priv->glz_dict) { return; } - pthread_mutex_lock(&dcc->glz_drawables_inst_to_free_lock); - while ((ring_link = ring_get_head(&dcc->glz_drawables_inst_to_free))) { + pthread_mutex_lock(&dcc->priv->glz_drawables_inst_to_free_lock); + while ((ring_link = ring_get_head(&dcc->priv->glz_drawables_inst_to_free))) { GlzDrawableInstanceItem *drawable_instance = SPICE_CONTAINEROF(ring_link, GlzDrawableInstanceItem, free_link); dcc_free_glz_drawable_instance(dcc, drawable_instance); } - pthread_mutex_unlock(&dcc->glz_drawables_inst_to_free_lock); + pthread_mutex_unlock(&dcc->priv->glz_drawables_inst_to_free_lock); } /* Clear all lz drawables - enforce their removal from the global dictionary. @@ -528,7 +529,7 @@ void dcc_free_glz_drawables_to_free(DisplayChannelClient* dcc) void dcc_free_glz_drawables(DisplayChannelClient *dcc) { RingItem *ring_link; - GlzSharedDictionary *glz_dict = dcc ? dcc->glz_dict : NULL; + GlzSharedDictionary *glz_dict = dcc ? dcc->priv->glz_dict : NULL; if (!glz_dict) { return; @@ -536,7 +537,7 @@ void dcc_free_glz_drawables(DisplayChannelClient *dcc) // assure no display channel is during global lz encoding pthread_rwlock_wrlock(&glz_dict->encode_lock); - while ((ring_link = ring_get_head(&dcc->glz_drawables))) { + while ((ring_link = ring_get_head(&dcc->priv->glz_drawables))) { RedGlzDrawable *drawable = SPICE_CONTAINEROF(ring_link, RedGlzDrawable, link); // no need to lock the to_free list, since we assured no other thread is encoding and // thus not other thread access the to_free list of the channel @@ -547,9 +548,9 @@ void dcc_free_glz_drawables(DisplayChannelClient *dcc) void dcc_freeze_glz(DisplayChannelClient *dcc) { - pthread_rwlock_wrlock(&dcc->glz_dict->encode_lock); - dcc->glz_dict->migrate_freeze = TRUE; - pthread_rwlock_unlock(&dcc->glz_dict->encode_lock); + pthread_rwlock_wrlock(&dcc->priv->glz_dict->encode_lock); + dcc->priv->glz_dict->migrate_freeze = TRUE; + pthread_rwlock_unlock(&dcc->priv->glz_dict->encode_lock); } static GlzSharedDictionary *glz_shared_dictionary_new(RedClient *client, uint8_t id, @@ -596,21 +597,23 @@ static GlzSharedDictionary *create_glz_dictionary(DisplayChannelClient *dcc, uint8_t id, int window_size) { spice_info("Lz Window %d Size=%d", id, window_size); + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); GlzEncDictContext *glz_dict = - glz_enc_dictionary_create(window_size, MAX_LZ_ENCODERS, &dcc->glz_data.usr); + glz_enc_dictionary_create(window_size, MAX_LZ_ENCODERS, &dcc->priv->glz_data.usr); - return glz_shared_dictionary_new(RED_CHANNEL_CLIENT(dcc)->client, id, glz_dict); + return glz_shared_dictionary_new(client, id, glz_dict); } GlzSharedDictionary *get_glz_dictionary_for_dcc(DisplayChannelClient *dcc, uint8_t id, int window_size) { GlzSharedDictionary *shared_dict; + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); pthread_mutex_lock(&glz_dictionary_list_lock); - shared_dict = find_glz_dictionary(RED_CHANNEL_CLIENT(dcc)->client, id); + shared_dict = find_glz_dictionary(client, id); if (shared_dict) { shared_dict->refs++; } else { @@ -626,10 +629,11 @@ static GlzSharedDictionary *restore_glz_dictionary(DisplayChannelClient *dcc, uint8_t id, GlzEncDictRestoreData *restore_data) { + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); GlzEncDictContext *glz_dict = - glz_enc_dictionary_restore(restore_data, &dcc->glz_data.usr); + glz_enc_dictionary_restore(restore_data, &dcc->priv->glz_data.usr); - return glz_shared_dictionary_new(RED_CHANNEL_CLIENT(dcc)->client, id, glz_dict); + return glz_shared_dictionary_new(client, id, glz_dict); } GlzSharedDictionary *restore_glz_dictionary_for_dcc(DisplayChannelClient *dcc, @@ -637,10 +641,11 @@ GlzSharedDictionary *restore_glz_dictionary_for_dcc(DisplayChannelClient *dcc, GlzEncDictRestoreData *restore_data) { GlzSharedDictionary *shared_dict = NULL; + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); pthread_mutex_lock(&glz_dictionary_list_lock); - shared_dict = find_glz_dictionary(RED_CHANNEL_CLIENT(dcc)->client, id); + shared_dict = find_glz_dictionary(client, id); if (shared_dict) { shared_dict->refs++; @@ -660,14 +665,14 @@ void dcc_release_glz(DisplayChannelClient *dcc) dcc_free_glz_drawables(dcc); - glz_encoder_destroy(dcc->glz); - dcc->glz = NULL; + glz_encoder_destroy(dcc->priv->glz); + dcc->priv->glz = NULL; - if (!(shared_dict = dcc->glz_dict)) { + if (!(shared_dict = dcc->priv->glz_dict)) { return; } - dcc->glz_dict = NULL; + dcc->priv->glz_dict = NULL; pthread_mutex_lock(&glz_dictionary_list_lock); if (--shared_dict->refs) { pthread_mutex_unlock(&glz_dictionary_list_lock); @@ -675,6 +680,6 @@ void dcc_release_glz(DisplayChannelClient *dcc) } ring_remove(&shared_dict->base); pthread_mutex_unlock(&glz_dictionary_list_lock); - glz_enc_dictionary_destroy(shared_dict->dict, &dcc->glz_data.usr); + glz_enc_dictionary_destroy(shared_dict->dict, &dcc->priv->glz_data.usr); free(shared_dict); } diff --git a/server/dcc-encoders.h b/server/dcc-encoders.h index 00930ddb..630125d9 100644 --- a/server/dcc-encoders.h +++ b/server/dcc-encoders.h @@ -34,8 +34,6 @@ typedef struct RedCompressBuf RedCompressBuf; typedef struct _GlzDrawableInstanceItem GlzDrawableInstanceItem; typedef struct _RedGlzDrawable RedGlzDrawable; -/* FIXME: remove */ -typedef struct _DisplayChannelClient DisplayChannelClient; void dcc_encoders_init (DisplayChannelClient *dcc); void dcc_free_glz_drawable_instance (DisplayChannelClient *dcc, diff --git a/server/dcc-private.h b/server/dcc-private.h index a2ad0119..28466d7e 100644 --- a/server/dcc-private.h +++ b/server/dcc-private.h @@ -24,8 +24,7 @@ #include "dcc-encoders.h" #include "stream.h" -struct _DisplayChannelClient { - CommonWorkerChannelClient common; +struct _DisplayChannelClientPrivate { spice_image_compression_t image_compression; spice_wan_compression_t jpeg_state; spice_wan_compression_t zlib_glz_state; @@ -74,10 +73,10 @@ struct _DisplayChannelClient { Ring glz_drawables_inst_to_free; // list of instances to be freed pthread_mutex_t glz_drawables_inst_to_free_lock; - uint8_t surface_client_created[NUM_SURFACES]; - QRegion surface_client_lossy_region[NUM_SURFACES]; + uint8_t *surface_client_created; + QRegion *surface_client_lossy_region; - StreamAgent stream_agents[NUM_STREAMS]; + StreamAgent *stream_agents; int use_mjpeg_encoder_rate_control; uint32_t streams_max_latency; uint64_t streams_max_bit_rate; diff --git a/server/dcc-send.c b/server/dcc-send.c index dcc1b0be..aea7a978 100644 --- a/server/dcc-send.c +++ b/server/dcc-send.c @@ -29,7 +29,7 @@ typedef struct BitmapData { static int dcc_pixmap_cache_hit(DisplayChannelClient *dcc, uint64_t id, int *lossy) { - PixmapCache *cache = dcc->pixmap_cache; + PixmapCache *cache = dcc->priv->pixmap_cache; NewCacheItem *item; uint64_t serial; @@ -39,11 +39,12 @@ static int dcc_pixmap_cache_hit(DisplayChannelClient *dcc, uint64_t id, int *los while (item) { if (item->id == id) { + uint32_t client_id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); ring_remove(&item->lru_link); ring_add(&cache->lru, &item->lru_link); - spice_assert(dcc->common.id < MAX_CACHE_CLIENTS); - item->sync[dcc->common.id] = serial; - cache->sync[dcc->common.id] = serial; + spice_assert(client_id < MAX_CACHE_CLIENTS); + item->sync[client_id] = serial; + cache->sync[client_id] = serial; *lossy = item->lossy; break; } @@ -66,7 +67,7 @@ static int is_surface_area_lossy(DisplayChannelClient *dcc, uint32_t surface_id, spice_return_val_if_fail(validate_surface(display, surface_id), FALSE); surface = &display->surfaces[surface_id]; - surface_lossy_region = &dcc->surface_client_lossy_region[surface_id]; + surface_lossy_region = &dcc->priv->surface_client_lossy_region[surface_id]; if (!area) { if (region_is_empty(surface_lossy_region)) { @@ -98,7 +99,7 @@ static int is_surface_area_lossy(DisplayChannelClient *dcc, uint32_t surface_id, static int is_bitmap_lossy(RedChannelClient *rcc, SpiceImage *image, SpiceRect *area, Drawable *drawable, BitmapData *out_data) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); if (image == NULL) { // self bitmap @@ -154,15 +155,17 @@ static int is_brush_lossy(RedChannelClient *rcc, SpiceBrush *brush, static PipeItem *dcc_get_tail(DisplayChannelClient *dcc) { - return (PipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe); + return (PipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->priv->pipe); } static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc, SpiceImage *image, SpiceImage *io_image, int is_lossy) { - DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base); - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannel *display_channel = + SPICE_CONTAINEROF(red_channel_client_get_channel(rcc), DisplayChannel, + common.base); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); if ((image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) { spice_assert(image->descriptor.width * image->descriptor.height > 0); @@ -171,8 +174,8 @@ static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc, image->descriptor.width * image->descriptor.height, is_lossy)) { io_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME; - dcc->send_data.pixmap_cache_items[dcc->send_data.num_pixmap_cache_items++] = - image->descriptor.id; + dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++] = + image->descriptor.id; reds_stat_inc_counter(reds, display_channel->add_to_cache_counter, 1); } } @@ -206,8 +209,8 @@ static void marshal_sub_msg_inval_list_wait(SpiceMarshaller *m, /* use legacy SpiceDataHeader (with sub_list) */ static void send_free_list_legacy(RedChannelClient *rcc) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); - FreeList *free_list = &dcc->send_data.free_list; + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); + FreeList *free_list = &dcc->priv->send_data.free_list; SpiceMarshaller *marshaller; int sub_list_len = 1; SpiceMarshaller *wait_m = NULL; @@ -237,8 +240,8 @@ static void send_free_list_legacy(RedChannelClient *rcc) /* use mini header and SPICE_MSG_LIST */ static void send_free_list(RedChannelClient *rcc) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); - FreeList *free_list = &dcc->send_data.free_list; + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); + FreeList *free_list = &dcc->priv->send_data.free_list; int sub_list_len = 1; SpiceMarshaller *urgent_marshaller; SpiceMarshaller *wait_m = NULL; @@ -249,14 +252,14 @@ static void send_free_list(RedChannelClient *rcc) int i; urgent_marshaller = red_channel_client_switch_to_urgent_sender(rcc); - for (i = 0; i < dcc->send_data.num_pixmap_cache_items; i++) { + for (i = 0; i < dcc->priv->send_data.num_pixmap_cache_items; i++) { int dummy; /* When using the urgent marshaller, the serial number of the message that is * going to be sent right after the SPICE_MSG_LIST, is increased by one. * But all this message pixmaps cache references used its old serial. * we use pixmap_cache_items to collect these pixmaps, and we update their serial * by calling pixmap_cache_hit. */ - dcc_pixmap_cache_hit(dcc, dcc->send_data.pixmap_cache_items[i], &dummy); + dcc_pixmap_cache_hit(dcc, dcc->priv->send_data.pixmap_cache_items[i], &dummy); } if (free_list->wait.header.wait_count) { @@ -326,7 +329,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m, if ((simage->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) { int lossy_cache_item; if (dcc_pixmap_cache_hit(dcc, image.descriptor.id, &lossy_cache_item)) { - dcc->send_data.pixmap_cache_items[dcc->send_data.num_pixmap_cache_items++] = + dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++] = image.descriptor.id; if (can_lossy || !lossy_cache_item) { if (!display->enable_jpeg || lossy_cache_item) { @@ -344,7 +347,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m, reds_stat_inc_counter(reds, display->cache_hits_counter, 1); return FILL_BITS_TYPE_CACHE; } else { - pixmap_cache_set_lossy(dcc->pixmap_cache, simage->descriptor.id, + pixmap_cache_set_lossy(dcc->priv->pixmap_cache, simage->descriptor.id, FALSE); image.descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME; } @@ -383,7 +386,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m, /* Images must be added to the cache only after they are compressed in order to prevent starvation in the client between pixmap_cache and global dictionary (in cases of multiple monitors) */ - if (reds_stream_get_family(rcc->stream) == AF_UNIX || + if (reds_stream_get_family(rcc->priv->stream) == AF_UNIX || !dcc_compress_image(dcc, &image, &simage->u.bitmap, drawable, can_lossy, &comp_send_data)) { SpicePalette *palette; @@ -445,15 +448,15 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m, static void fill_mask(RedChannelClient *rcc, SpiceMarshaller *m, SpiceImage *mask_bitmap, Drawable *drawable) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); if (mask_bitmap && m) { - if (dcc->image_compression != SPICE_IMAGE_COMPRESS_OFF) { + if (dcc->priv->image_compression != SPICE_IMAGE_COMPRESS_OFF) { /* todo: pass compression argument */ - spice_image_compression_t save_img_comp = dcc->image_compression; - dcc->image_compression = SPICE_IMAGE_COMPRESS_OFF; + spice_image_compression_t save_img_comp = dcc->priv->image_compression; + dcc->priv->image_compression = SPICE_IMAGE_COMPRESS_OFF; fill_bits(dcc, m, mask_bitmap, drawable, FALSE); - dcc->image_compression = save_img_comp; + dcc->priv->image_compression = save_img_comp; } else { fill_bits(dcc, m, mask_bitmap, drawable, FALSE); } @@ -477,7 +480,7 @@ static void marshall_qxl_draw_fill(RedChannelClient *rcc, { Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMarshaller *brush_pat_out; SpiceMarshaller *mask_bitmap_out; SpiceFill fill; @@ -511,7 +514,7 @@ static void surface_lossy_region_update(DisplayChannelClient *dcc, return; } - surface_lossy_region = &dcc->surface_client_lossy_region[item->surface_id]; + surface_lossy_region = &dcc->priv->surface_client_lossy_region[item->surface_id]; drawable = item->red_drawable; if (drawable->clip.type == SPICE_CLIP_TYPE_RECTS ) { @@ -563,7 +566,7 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc Ring *pipe; spice_assert(num_surfaces); - pipe = &RED_CHANNEL_CLIENT(dcc)->pipe; + pipe = &RED_CHANNEL_CLIENT(dcc)->priv->pipe; for (pipe_item = (PipeItem *)ring_get_head(pipe); pipe_item; @@ -656,7 +659,7 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient resent_areas[0] = *first_area; num_resent = 1; - pipe = &RED_CHANNEL_CLIENT(dcc)->pipe; + pipe = &RED_CHANNEL_CLIENT(dcc)->priv->pipe; // going from the oldest to the newest for (pipe_item = (PipeItem *)ring_get_tail(pipe); @@ -702,7 +705,7 @@ static void red_add_lossless_drawable_dependencies(RedChannelClient *rcc, SpiceRect *deps_areas[], int num_deps) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); DisplayChannel *display = DCC_TO_DC(dcc); RedDrawable *drawable = item->red_drawable; int sync_rendered = FALSE; @@ -769,7 +772,7 @@ static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc, SpiceMarshaller *m, DrawablePipeItem *dpi) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; @@ -826,7 +829,7 @@ static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, DrawablePipeItem *dpi, int src_allowed_lossy) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; SpiceMarshaller *brush_pat_out; @@ -859,7 +862,7 @@ static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc, SpiceMarshaller *m, DrawablePipeItem *dpi) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; @@ -924,7 +927,7 @@ static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, DrawablePipeItem *dpi, int src_allowed_lossy) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; SpiceMarshaller *src_bitmap_out; @@ -950,7 +953,7 @@ static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, DrawablePipeItem *dpi) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; int has_mask = !!drawable->u.copy.mask.bitmap; @@ -975,7 +978,7 @@ static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, DrawablePipeItem *dpi) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Drawable *item = dpi->drawable; RedDrawable *drawable = item->red_drawable; SpiceMarshaller *src_bitmap_out; @@ -1024,7 +1027,7 @@ static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc, int src_allowed_lossy) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceMarshaller *src_bitmap_out; SpiceAlphaBlend alpha_blend; @@ -1048,7 +1051,7 @@ static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int src_is_lossy; BitmapData src_bitmap_data; @@ -1090,7 +1093,7 @@ static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceRect src_rect; int horz_offset; @@ -1119,7 +1122,7 @@ static void red_marshall_qxl_draw_blend(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceMarshaller *src_bitmap_out; SpiceMarshaller *mask_bitmap_out; @@ -1143,7 +1146,7 @@ static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int src_is_lossy; BitmapData src_bitmap_data; @@ -1205,7 +1208,7 @@ static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int has_mask = !!drawable->u.blackness.mask.bitmap; @@ -1239,7 +1242,7 @@ static void red_lossy_marshall_qxl_draw_whiteness(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int has_mask = !!drawable->u.whiteness.mask.bitmap; @@ -1279,7 +1282,7 @@ static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceRop3 rop3; SpiceMarshaller *src_bitmap_out; @@ -1308,7 +1311,7 @@ static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int src_is_lossy; BitmapData src_bitmap_data; @@ -1363,7 +1366,7 @@ static void red_marshall_qxl_draw_composite(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceMarshaller *src_bitmap_out; SpiceMarshaller *mask_bitmap_out; @@ -1388,7 +1391,7 @@ static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int src_is_lossy; BitmapData src_bitmap_data; @@ -1444,7 +1447,7 @@ static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceStroke stroke; SpiceMarshaller *brush_pat_out; @@ -1469,7 +1472,7 @@ static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int brush_is_lossy; BitmapData brush_bitmap_data; @@ -1524,7 +1527,7 @@ static void red_marshall_qxl_draw_text(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; SpiceText text; SpiceMarshaller *brush_pat_out; @@ -1551,7 +1554,7 @@ static void red_lossy_marshall_qxl_draw_text(RedChannelClient *rcc, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *drawable = item->red_drawable; int fg_is_lossy; BitmapData fg_bitmap_data; @@ -1618,7 +1621,7 @@ static int encode_frame(DisplayChannelClient *dcc, const SpiceRect *src, { size_t offset; int i, chunk; - StreamAgent *agent = &dcc->stream_agents[get_stream_id(DCC_TO_DC(dcc), stream)]; + StreamAgent *agent = &dcc->priv->stream_agents[get_stream_id(DCC_TO_DC(dcc), stream)]; offset = 0; chunk = 0; @@ -1650,7 +1653,7 @@ static int encode_frame(DisplayChannelClient *dcc, const SpiceRect *src, static int red_marshall_stream_data(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, Drawable *drawable) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); DisplayChannel *display = DCC_TO_DC(dcc); Stream *stream = drawable->stream; SpiceImage *image; @@ -1685,11 +1688,11 @@ static int red_marshall_stream_data(RedChannelClient *rcc, height = stream->height; } - StreamAgent *agent = &dcc->stream_agents[get_stream_id(display, stream)]; + StreamAgent *agent = &dcc->priv->stream_agents[get_stream_id(display, stream)]; uint64_t time_now = red_get_monotonic_time(); size_t outbuf_size; - if (!dcc->use_mjpeg_encoder_rate_control) { + if (!dcc->priv->use_mjpeg_encoder_rate_control) { if (time_now - agent->last_send_time < (1000 * 1000 * 1000) / agent->fps) { agent->frames--; #ifdef STREAM_STATS @@ -1703,15 +1706,15 @@ static int red_marshall_stream_data(RedChannelClient *rcc, frame_mm_time = drawable->red_drawable->mm_time ? drawable->red_drawable->mm_time : reds_get_mm_time(); - outbuf_size = dcc->send_data.stream_outbuf_size; + outbuf_size = dcc->priv->send_data.stream_outbuf_size; ret = mjpeg_encoder_start_frame(agent->mjpeg_encoder, image->u.bitmap.format, width, height, - &dcc->send_data.stream_outbuf, + &dcc->priv->send_data.stream_outbuf, &outbuf_size, frame_mm_time); switch (ret) { case MJPEG_ENCODER_FRAME_DROP: - spice_assert(dcc->use_mjpeg_encoder_rate_control); + spice_assert(dcc->priv->use_mjpeg_encoder_rate_control); #ifdef STREAM_STATS agent->stats.num_drops_fps++; #endif @@ -1730,7 +1733,7 @@ static int red_marshall_stream_data(RedChannelClient *rcc, return FALSE; } n = mjpeg_encoder_end_frame(agent->mjpeg_encoder); - dcc->send_data.stream_outbuf_size = outbuf_size; + dcc->priv->send_data.stream_outbuf_size = outbuf_size; if (!drawable->sized_stream) { SpiceMsgDisplayStreamData stream_data; @@ -1759,7 +1762,7 @@ static int red_marshall_stream_data(RedChannelClient *rcc, spice_marshall_msg_display_stream_data_sized(base_marshaller, &stream_data); } spice_marshaller_add_ref(base_marshaller, - dcc->send_data.stream_outbuf, n); + dcc->priv->send_data.stream_outbuf, n); agent->last_send_time = time_now; #ifdef STREAM_STATS agent->stats.num_frames_sent++; @@ -1783,7 +1786,7 @@ static void display_channel_marshall_migrate_data_surfaces(DisplayChannelClient for (i = 0; i < NUM_SURFACES; i++) { SpiceRect lossy_rect; - if (!dcc->surface_client_created[i]) { + if (!dcc->priv->surface_client_created[i]) { continue; } spice_marshaller_add_uint32(m2, i); @@ -1792,7 +1795,7 @@ static void display_channel_marshall_migrate_data_surfaces(DisplayChannelClient if (!lossy) { continue; } - region_extents(&dcc->surface_client_lossy_region[i], &lossy_rect); + region_extents(&dcc->priv->surface_client_lossy_region[i], &lossy_rect); spice_marshaller_add_int32(m2, lossy_rect.left); spice_marshaller_add_int32(m2, lossy_rect.top); spice_marshaller_add_int32(m2, lossy_rect.right); @@ -1804,34 +1807,35 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc, SpiceMarshaller *base_marshaller) { DisplayChannel *display_channel; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMigrateDataDisplay display_data = {0,}; - display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base); + display_channel = SPICE_CONTAINEROF(red_channel_client_get_channel(rcc), + DisplayChannel, common.base); red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, NULL); spice_marshaller_add_uint32(base_marshaller, SPICE_MIGRATE_DATA_DISPLAY_MAGIC); spice_marshaller_add_uint32(base_marshaller, SPICE_MIGRATE_DATA_DISPLAY_VERSION); - spice_assert(dcc->pixmap_cache); + spice_assert(dcc->priv->pixmap_cache); spice_assert(MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS == 4 && MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS == MAX_CACHE_CLIENTS); display_data.message_serial = red_channel_client_get_message_serial(rcc); - display_data.low_bandwidth_setting = dcc->common.is_low_bandwidth; + display_data.low_bandwidth_setting = common_worker_channel_client_is_low_bandwidth(COMMON_WORKER_CHANNEL_CLIENT(dcc)); - display_data.pixmap_cache_freezer = pixmap_cache_freeze(dcc->pixmap_cache); - display_data.pixmap_cache_id = dcc->pixmap_cache->id; - display_data.pixmap_cache_size = dcc->pixmap_cache->size; - memcpy(display_data.pixmap_cache_clients, dcc->pixmap_cache->sync, + display_data.pixmap_cache_freezer = pixmap_cache_freeze(dcc->priv->pixmap_cache); + display_data.pixmap_cache_id = dcc->priv->pixmap_cache->id; + display_data.pixmap_cache_size = dcc->priv->pixmap_cache->size; + memcpy(display_data.pixmap_cache_clients, dcc->priv->pixmap_cache->sync, sizeof(display_data.pixmap_cache_clients)); - spice_assert(dcc->glz_dict); + spice_assert(dcc->priv->glz_dict); dcc_freeze_glz(dcc); - display_data.glz_dict_id = dcc->glz_dict->id; - glz_enc_dictionary_get_restore_data(dcc->glz_dict->dict, + display_data.glz_dict_id = dcc->priv->glz_dict->id; + glz_enc_dictionary_get_restore_data(dcc->priv->glz_dict->dict, &display_data.glz_dict_data, - &dcc->glz_data.usr); + &dcc->priv->glz_data.usr); /* all data besided the surfaces ref */ spice_marshaller_add(base_marshaller, @@ -1843,12 +1847,12 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc, static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc, SpiceMarshaller *base_marshaller) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMsgWaitForChannels wait; PixmapCache *pixmap_cache; red_channel_client_init_send_data(rcc, SPICE_MSG_WAIT_FOR_CHANNELS, NULL); - pixmap_cache = dcc->pixmap_cache; + pixmap_cache = dcc->priv->pixmap_cache; pthread_mutex_lock(&pixmap_cache->lock); @@ -1856,8 +1860,8 @@ static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc, wait.wait_list[0].channel_type = SPICE_CHANNEL_DISPLAY; wait.wait_list[0].channel_id = pixmap_cache->generation_initiator.client; wait.wait_list[0].message_serial = pixmap_cache->generation_initiator.message; - dcc->pixmap_cache_generation = pixmap_cache->generation; - dcc->pending_pixmaps_sync = FALSE; + dcc->priv->pixmap_cache_generation = pixmap_cache->generation; + dcc->priv->pending_pixmaps_sync = FALSE; pthread_mutex_unlock(&pixmap_cache->lock); @@ -1866,23 +1870,24 @@ static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc, static void dcc_pixmap_cache_reset(DisplayChannelClient *dcc, SpiceMsgWaitForChannels* sync_data) { - PixmapCache *cache = dcc->pixmap_cache; + PixmapCache *cache = dcc->priv->pixmap_cache; uint8_t wait_count; uint64_t serial; uint32_t i; + uint32_t client_id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); serial = red_channel_client_get_message_serial(RED_CHANNEL_CLIENT(dcc)); pthread_mutex_lock(&cache->lock); pixmap_cache_clear(cache); - dcc->pixmap_cache_generation = ++cache->generation; - cache->generation_initiator.client = dcc->common.id; + dcc->priv->pixmap_cache_generation = ++cache->generation; + cache->generation_initiator.client = client_id; cache->generation_initiator.message = serial; - cache->sync[dcc->common.id] = serial; + cache->sync[client_id] = serial; wait_count = 0; for (i = 0; i < MAX_CACHE_CLIENTS; i++) { - if (cache->sync[i] && i != dcc->common.id) { + if (cache->sync[i] && i != client_id) { sync_data->wait_list[wait_count].channel_type = SPICE_CHANNEL_DISPLAY; sync_data->wait_list[wait_count].channel_id = i; sync_data->wait_list[wait_count++].message_serial = cache->sync[i]; @@ -1895,7 +1900,7 @@ static void dcc_pixmap_cache_reset(DisplayChannelClient *dcc, SpiceMsgWaitForCha static void display_channel_marshall_reset_cache(RedChannelClient *rcc, SpiceMarshaller *base_marshaller) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMsgWaitForChannels wait; red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS, NULL); @@ -1907,7 +1912,7 @@ static void display_channel_marshall_reset_cache(RedChannelClient *rcc, static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageItem *item) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); DisplayChannel *display = DCC_TO_DC(dcc); SpiceImage red_image; RedWorker *worker; @@ -1971,7 +1976,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI compress_send_data_t comp_send_data = {0}; - comp_mode = dcc->image_compression; + comp_mode = dcc->priv->image_compression; if (((comp_mode == SPICE_IMAGE_COMPRESS_AUTO_LZ) || (comp_mode == SPICE_IMAGE_COMPRESS_AUTO_GLZ)) && !bitmap_has_extra_stride(&bitmap)) { @@ -2001,7 +2006,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI #ifdef USE_LZ4 if (comp_mode == SPICE_IMAGE_COMPRESS_LZ4 && bitmap_fmt_is_rgb(bitmap.format) && - red_channel_client_test_remote_cap(&dcc->common.base, + red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) { comp_succeeded = dcc_compress_image_lz4(dcc, &red_image, &bitmap, &comp_send_data, @@ -2011,7 +2016,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI comp_succeeded = dcc_compress_image_lz(dcc, &red_image, &bitmap, &comp_send_data, groupid); } - surface_lossy_region = &dcc->surface_client_lossy_region[item->surface_id]; + surface_lossy_region = &dcc->priv->surface_client_lossy_region[item->surface_id]; if (comp_succeeded) { spice_marshall_Image(src_bitmap_out, &red_image, &bitmap_palette_out, &lzplt_palette_out); @@ -2152,7 +2157,9 @@ static void marshall_qxl_drawable(RedChannelClient *rcc, SpiceMarshaller *m, DrawablePipeItem *dpi) { Drawable *item = dpi->drawable; - DisplayChannel *display = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base); + DisplayChannel *display = + SPICE_CONTAINEROF(red_channel_client_get_channel(rcc), DisplayChannel, + common.base); spice_return_if_fail(display); spice_return_if_fail(rcc); @@ -2170,7 +2177,7 @@ static void marshall_qxl_drawable(RedChannelClient *rcc, static void marshall_stream_start(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, StreamAgent *agent) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); Stream *stream = agent->stream; agent->last_send_time = 0; @@ -2208,7 +2215,7 @@ static void marshall_stream_clip(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, StreamClipItem *item) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); StreamAgent *agent = item->stream_agent; spice_return_if_fail(agent->stream); @@ -2226,7 +2233,7 @@ static void marshall_stream_clip(RedChannelClient *rcc, static void marshall_stream_end(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, StreamAgent* agent) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMsgDisplayStreamDestroy destroy; red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_DESTROY, NULL); @@ -2238,12 +2245,13 @@ static void marshall_stream_end(RedChannelClient *rcc, static void marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller *m, UpgradeItem *item) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedDrawable *red_drawable; SpiceMsgDisplayDrawCopy copy; SpiceMarshaller *src_bitmap_out, *mask_bitmap_out; + RedChannel *channel = red_channel_client_get_channel(rcc); - spice_assert(rcc && rcc->channel && item && item->drawable); + spice_assert(rcc && channel && item && item->drawable); red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_DRAW_COPY, &item->base); red_drawable = item->drawable->red_drawable; @@ -2267,9 +2275,9 @@ static void marshall_surface_create(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, SpiceMsgSurfaceCreate *surface_create) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); - region_init(&dcc->surface_client_lossy_region[surface_create->surface_id]); + region_init(&dcc->priv->surface_client_lossy_region[surface_create->surface_id]); red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_SURFACE_CREATE, NULL); spice_marshall_msg_display_surface_create(base_marshaller, surface_create); @@ -2278,10 +2286,10 @@ static void marshall_surface_create(RedChannelClient *rcc, static void marshall_surface_destroy(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, uint32_t surface_id) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); SpiceMsgSurfaceDestroy surface_destroy; - region_destroy(&dcc->surface_client_lossy_region[surface_id]); + region_destroy(&dcc->priv->surface_client_lossy_region[surface_id]); red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_SURFACE_DESTROY, NULL); surface_destroy.surface_id = surface_id; @@ -2320,8 +2328,8 @@ static void marshall_stream_activate_report(RedChannelClient *rcc, SpiceMarshaller *base_marshaller, uint32_t stream_id) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); - StreamAgent *agent = &dcc->stream_agents[stream_id]; + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); + StreamAgent *agent = &dcc->priv->stream_agents[stream_id]; SpiceMsgDisplayStreamActivateReport msg; red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_ACTIVATE_REPORT, NULL); @@ -2334,15 +2342,16 @@ static void marshall_stream_activate_report(RedChannelClient *rcc, static void begin_send_message(RedChannelClient *rcc) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); - FreeList *free_list = &dcc->send_data.free_list; + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); + FreeList *free_list = &dcc->priv->send_data.free_list; if (free_list->res->count) { int sync_count = 0; int i; + uint32_t client_id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); for (i = 0; i < MAX_CACHE_CLIENTS; i++) { - if (i != dcc->common.id && free_list->sync[i] != 0) { + if (i != client_id && free_list->sync[i] != 0) { free_list->wait.header.wait_list[sync_count].channel_type = SPICE_CHANNEL_DISPLAY; free_list->wait.header.wait_list[sync_count].channel_id = i; free_list->wait.header.wait_list[sync_count++].message_serial = free_list->sync[i]; @@ -2350,7 +2359,7 @@ static void begin_send_message(RedChannelClient *rcc) } free_list->wait.header.wait_count = sync_count; - if (rcc->is_mini_header) { + if (rcc->priv->is_mini_header) { send_free_list(rcc); } else { send_free_list_legacy(rcc); @@ -2361,9 +2370,9 @@ static void begin_send_message(RedChannelClient *rcc) static void reset_send_data(DisplayChannelClient *dcc) { - dcc->send_data.free_list.res->count = 0; - dcc->send_data.num_pixmap_cache_items = 0; - memset(dcc->send_data.free_list.sync, 0, sizeof(dcc->send_data.free_list.sync)); + dcc->priv->send_data.free_list.res->count = 0; + dcc->priv->send_data.num_pixmap_cache_items = 0; + memset(dcc->priv->send_data.free_list.sync, 0, sizeof(dcc->priv->send_data.free_list.sync)); } void dcc_send_item(DisplayChannelClient *dcc, PipeItem *pipe_item) diff --git a/server/dcc.c b/server/dcc.c index 42c85e16..499a2bfd 100644 --- a/server/dcc.c +++ b/server/dcc.c @@ -15,10 +15,163 @@ You should have received a copy of the GNU Lesser General Public License along with this library; if not, see <http://www.gnu.org/licenses/>. */ + #include "dcc-private.h" +#include "dcc.h" #include "display-channel.h" +#include "red-channel-client-private.h" +#include "spice-server-enums.h" + +G_DEFINE_TYPE(DisplayChannelClient, display_channel_client, TYPE_COMMON_WORKER_CHANNEL_CLIENT) + +#define DISPLAY_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_DISPLAY_CHANNEL_CLIENT, DisplayChannelClientPrivate)) #define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano +#define DISPLAY_FREE_LIST_DEFAULT_SIZE 128 + + enum +{ + PROP0, + PROP_IMAGE_COMPRESSION, + PROP_JPEG_STATE, + PROP_ZLIB_GLZ_STATE +}; +static void +display_channel_client_get_property(GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + DisplayChannelClient *self = DISPLAY_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_IMAGE_COMPRESSION: + g_value_set_enum(value, self->priv->image_compression); + break; + case PROP_JPEG_STATE: + g_value_set_enum(value, self->priv->jpeg_state); + break; + case PROP_ZLIB_GLZ_STATE: + g_value_set_enum(value, self->priv->zlib_glz_state); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void +display_channel_client_set_property(GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + DisplayChannelClient *self = DISPLAY_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_IMAGE_COMPRESSION: + self->priv->image_compression = g_value_get_enum(value); + break; + case PROP_JPEG_STATE: + self->priv->jpeg_state = g_value_get_enum(value); + break; + case PROP_ZLIB_GLZ_STATE: + self->priv->zlib_glz_state = g_value_get_enum(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void dcc_init_stream_agents(DisplayChannelClient *dcc); + +static void +display_channel_client_constructed(GObject *object) +{ + DisplayChannelClient *self = DISPLAY_CHANNEL_CLIENT(object); + + G_OBJECT_CLASS(display_channel_client_parent_class)->constructed(object); + + dcc_init_stream_agents(self); + dcc_encoders_init(self); + + self->priv->surface_client_created = g_new0(uint8_t, NUM_SURFACES); + self->priv->surface_client_lossy_region = g_new0(QRegion, NUM_SURFACES); +} + +static void +display_channel_client_finalize(GObject *object) +{ + DisplayChannelClient *self = DISPLAY_CHANNEL_CLIENT(object); + g_free(self->priv->stream_agents); + g_free(self->priv->surface_client_created); + g_free(self->priv->surface_client_lossy_region); + + G_OBJECT_CLASS(display_channel_client_parent_class)->finalize(object); +} + +static void +display_channel_client_class_init(DisplayChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(DisplayChannelClientPrivate)); + + object_class->get_property = display_channel_client_get_property; + object_class->set_property = display_channel_client_set_property; + object_class->constructed = display_channel_client_constructed; + object_class->finalize = display_channel_client_finalize; + + g_object_class_install_property(object_class, + PROP_IMAGE_COMPRESSION, + g_param_spec_enum("image-compression", + "image compression", + "Image compression type", + SPICE_TYPE_SPICE_IMAGE_COMPRESSION_T, + SPICE_IMAGE_COMPRESS_INVALID, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(object_class, + PROP_JPEG_STATE, + g_param_spec_enum("jpeg-state", + "jpeg state", + "JPEG compression state", + SPICE_TYPE_SPICE_WAN_COMPRESSION_T, + SPICE_WAN_COMPRESSION_INVALID, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(object_class, + PROP_ZLIB_GLZ_STATE, + g_param_spec_enum("zlib-glz-state", + "zlib glz state", + "zlib glz state", + SPICE_TYPE_SPICE_WAN_COMPRESSION_T, + SPICE_WAN_COMPRESSION_INVALID, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); +} + +static void display_channel_client_init(DisplayChannelClient *self) +{ + self->priv = DISPLAY_CHANNEL_CLIENT_PRIVATE(self); + + ring_init(&self->priv->palette_cache_lru); + self->priv->palette_cache_available = CLIENT_PALETTE_CACHE_SIZE; + // todo: tune quality according to bandwidth + self->priv->jpeg_quality = 85; + + size_t stream_buf_size; + stream_buf_size = 32*1024; + self->priv->send_data.stream_outbuf = spice_malloc(stream_buf_size); + self->priv->send_data.stream_outbuf_size = stream_buf_size; + self->priv->send_data.free_list.res = + spice_malloc(sizeof(SpiceResourceList) + + DISPLAY_FREE_LIST_DEFAULT_SIZE * sizeof(SpiceResourceID)); + self->priv->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE; +} static SurfaceCreateItem *surface_create_item_new(RedChannel* channel, uint32_t surface_id, uint32_t width, @@ -70,7 +223,7 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface no other drawable depends on them */ rcc = RED_CHANNEL_CLIENT(dcc); - ring = &rcc->pipe; + ring = &rcc->priv->pipe; item = (PipeItem *) ring; while ((item = (PipeItem *)ring_next(ring, (RingItem *)item))) { Drawable *drawable; @@ -135,19 +288,21 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id) { DisplayChannel *display = dcc ? DCC_TO_DC(dcc) : NULL; RedSurface *surface; + RedChannel *channel; SurfaceCreateItem *create; uint32_t flags = is_primary_surface(DCC_TO_DC(dcc), surface_id) ? SPICE_SURFACE_FLAGS_PRIMARY : 0; /* don't send redundant create surface commands to client */ if (!dcc || display->common.during_target_migrate || - dcc->surface_client_created[surface_id]) { + dcc->priv->surface_client_created[surface_id]) { return; } + channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(dcc)); surface = &display->surfaces[surface_id]; - create = surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel, + create = surface_create_item_new(channel, surface_id, surface->context.width, surface->context.height, surface->context.format, flags); - dcc->surface_client_created[surface_id] = TRUE; + dcc->priv->surface_client_created[surface_id] = TRUE; red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &create->pipe_item); } @@ -242,7 +397,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra surface_id = drawable->surface_deps[x]; if (surface_id != -1) { - if (dcc->surface_client_created[surface_id] == TRUE) { + if (dcc->priv->surface_client_created[surface_id] == TRUE) { continue; } dcc_create_surface(dcc, surface_id); @@ -251,7 +406,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra } } - if (dcc->surface_client_created[drawable->surface_id] == TRUE) { + if (dcc->priv->surface_client_created[drawable->surface_id] == TRUE) { return; } @@ -318,20 +473,19 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc) int i; DisplayChannel *display = DCC_TO_DC(dcc); + dcc->priv->stream_agents = g_new0(StreamAgent, NUM_STREAMS); for (i = 0; i < NUM_STREAMS; i++) { - StreamAgent *agent = &dcc->stream_agents[i]; + StreamAgent *agent = &dcc->priv->stream_agents[i]; agent->stream = &display->streams_buf[i]; region_init(&agent->vis_region); region_init(&agent->clip); pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE); pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY); } - dcc->use_mjpeg_encoder_rate_control = + dcc->priv->use_mjpeg_encoder_rate_control = red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT); } -#define DISPLAY_FREE_LIST_DEFAULT_SIZE 128 - DisplayChannelClient *dcc_new(DisplayChannel *display, RedClient *client, RedsStream *stream, int mig_target, @@ -343,35 +497,37 @@ DisplayChannelClient *dcc_new(DisplayChannel *display, { DisplayChannelClient *dcc; - - dcc = (DisplayChannelClient*)common_worker_channel_client_new( - COMMON_WORKER_CHANNEL(display), sizeof(DisplayChannelClient), - client, stream, mig_target, TRUE, - common_caps, num_common_caps, - caps, num_caps); - spice_return_val_if_fail(dcc, NULL); + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); + } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + + dcc = g_initable_new(TYPE_DISPLAY_CHANNEL_CLIENT, + NULL, NULL, + "channel", display, + "client", client, + "stream", stream, + "migration-target", mig_target, + "monitor-latency", TRUE, + "common-caps", common_caps_array, + "caps", caps_array, + "worker", COMMON_WORKER_CHANNEL(display)->worker, + "image-compression", image_compression, + "jpeg-state", jpeg_state, + "zlib-glz-state", zlib_glz_state, + NULL); spice_info("New display (client %p) dcc %p stream %p", client, dcc, stream); - ring_init(&dcc->palette_cache_lru); - dcc->palette_cache_available = CLIENT_PALETTE_CACHE_SIZE; - dcc->image_compression = image_compression; - dcc->jpeg_state = jpeg_state; - dcc->zlib_glz_state = zlib_glz_state; - // todo: tune quality according to bandwidth - dcc->jpeg_quality = 85; - - size_t stream_buf_size; - stream_buf_size = 32*1024; - dcc->send_data.stream_outbuf = spice_malloc(stream_buf_size); - dcc->send_data.stream_outbuf_size = stream_buf_size; - dcc->send_data.free_list.res = - spice_malloc(sizeof(SpiceResourceList) + - DISPLAY_FREE_LIST_DEFAULT_SIZE * sizeof(SpiceResourceID)); - dcc->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE; - - dcc_init_stream_agents(dcc); - - dcc_encoders_init(dcc); + if (common_caps_array) + g_array_unref(common_caps_array); + if (caps_array) + g_array_unref(caps_array); return dcc; } @@ -390,19 +546,20 @@ static void dcc_create_all_streams(DisplayChannelClient *dcc) /* TODO: this function is evil^Wsynchronous, fix */ static int display_channel_client_wait_for_init(DisplayChannelClient *dcc) { - dcc->expect_init = TRUE; + dcc->priv->expect_init = TRUE; uint64_t end_time = red_get_monotonic_time() + DISPLAY_CLIENT_TIMEOUT; for (;;) { red_channel_client_receive(RED_CHANNEL_CLIENT(dcc)); if (!red_channel_client_is_connected(RED_CHANNEL_CLIENT(dcc))) { break; } - if (dcc->pixmap_cache && dcc->glz_dict) { - dcc->pixmap_cache_generation = dcc->pixmap_cache->generation; + if (dcc->priv->pixmap_cache && dcc->priv->glz_dict) { + uint32_t id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); + dcc->priv->pixmap_cache_generation = dcc->priv->pixmap_cache->generation; /* TODO: move common.id? if it's used for a per client structure.. */ - spice_info("creating encoder with id == %d", dcc->common.id); - dcc->glz = glz_encoder_create(dcc->common.id, dcc->glz_dict->dict, &dcc->glz_data.usr); - if (!dcc->glz) { + spice_info("creating encoder with id == %d", id); + dcc->priv->glz = glz_encoder_create(id, dcc->priv->glz_dict->dict, &dcc->priv->glz_data.usr); + if (!dcc->priv->glz) { spice_critical("create global lz failed"); } return TRUE; @@ -447,7 +604,7 @@ static void dcc_destroy_stream_agents(DisplayChannelClient *dcc) int i; for (i = 0; i < NUM_STREAMS; i++) { - StreamAgent *agent = &dcc->stream_agents[i]; + StreamAgent *agent = &dcc->priv->stream_agents[i]; region_destroy(&agent->vis_region); region_destroy(&agent->clip); if (agent->mjpeg_encoder) { @@ -459,12 +616,12 @@ static void dcc_destroy_stream_agents(DisplayChannelClient *dcc) void dcc_stop(DisplayChannelClient *dcc) { - pixmap_cache_unref(dcc->pixmap_cache); - dcc->pixmap_cache = NULL; + pixmap_cache_unref(dcc->priv->pixmap_cache); + dcc->priv->pixmap_cache = NULL; dcc_release_glz(dcc); dcc_palette_cache_reset(dcc); - free(dcc->send_data.stream_outbuf); - free(dcc->send_data.free_list.res); + free(dcc->priv->send_data.stream_outbuf); + free(dcc->priv->send_data.free_list.res); dcc_destroy_stream_agents(dcc); } @@ -500,21 +657,23 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc) DisplayChannel *dc = DCC_TO_DC(dcc); MonitorsConfig *monitors_config = dc->monitors_config; MonitorsConfigItem *mci; + RedChannel *channel; if (monitors_config == NULL) { spice_warning("monitors_config is NULL"); return; } - if (!red_channel_client_test_remote_cap(&dcc->common.base, + if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_MONITORS_CONFIG)) { return; } - mci = monitors_config_item_new(dcc->common.base.channel, + channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(dcc)); + mci = monitors_config_item_new(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); + red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &mci->pipe_item); + red_channel_client_push(RED_CHANNEL_CLIENT(dcc)); } static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel, @@ -536,11 +695,11 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id) SurfaceDestroyItem *destroy; if (!dcc || COMMON_WORKER_CHANNEL(display)->during_target_migrate || - !dcc->surface_client_created[surface_id]) { + !dcc->priv->surface_client_created[surface_id]) { return; } - dcc->surface_client_created[surface_id] = FALSE; + dcc->priv->surface_client_created[surface_id] = FALSE; destroy = surface_destroy_item_new(channel, surface_id); red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy->pipe_item); } @@ -572,9 +731,9 @@ static RedGlzDrawable *get_glz_drawable(DisplayChannelClient *dcc, Drawable *dra ring_item_init(&ret->link); ring_item_init(&ret->drawable_link); - ring_add_before(&ret->link, &dcc->glz_drawables); + ring_add_before(&ret->link, &dcc->priv->glz_drawables); ring_add(&drawable->glz_ring, &ret->drawable_link); - dcc->glz_drawable_count++; + dcc->priv->glz_drawable_count++; return ret; } @@ -623,7 +782,7 @@ int dcc_compress_image_glz(DisplayChannelClient *dcc, #ifdef COMPRESS_STAT stat_time_t start_time = stat_now(worker); #endif - GlzData *glz_data = &dcc->glz_data; + GlzData *glz_data = &dcc->priv->glz_data; ZlibData *zlib_data; LzImageType type = bitmap_fmt_to_lz_image_type[src->format]; RedGlzDrawable *glz_drawable; @@ -644,7 +803,7 @@ int dcc_compress_image_glz(DisplayChannelClient *dcc, glz_data->data.u.lines_data.reverse = 0; /* fixme: remove? glz_data->usr.more_lines = glz_usr_more_lines; */ - glz_size = glz_encode(dcc->glz, type, src->x, src->y, + glz_size = glz_encode(dcc->priv->glz, type, src->x, src->y, (src->flags & SPICE_BITMAP_FLAGS_TOP_DOWN), NULL, 0, src->stride, glz_data->data.bufs_head->buf, sizeof(glz_data->data.bufs_head->buf), @@ -659,7 +818,7 @@ int dcc_compress_image_glz(DisplayChannelClient *dcc, #ifdef COMPRESS_STAT start_time = stat_now(worker); #endif - zlib_data = &dcc->zlib_data; + zlib_data = &dcc->priv->zlib_data; zlib_data->data.bufs_tail = compress_buf_new(); zlib_data->data.bufs_head = zlib_data->data.bufs_tail; @@ -668,7 +827,7 @@ int dcc_compress_image_glz(DisplayChannelClient *dcc, zlib_data->data.u.compressed_data.next = glz_data->data.bufs_head; zlib_data->data.u.compressed_data.size_left = glz_size; - zlib_size = zlib_encode(dcc->zlib, dcc->zlib_level, + zlib_size = zlib_encode(dcc->priv->zlib, dcc->priv->zlib_level, glz_size, (uint8_t*)zlib_data->data.bufs_head->buf, sizeof(zlib_data->data.bufs_head->buf)); @@ -705,8 +864,8 @@ int dcc_compress_image_lz(DisplayChannelClient *dcc, SpiceImage *dest, SpiceBitmap *src, compress_send_data_t* o_comp_data, uint32_t group_id) { - LzData *lz_data = &dcc->lz_data; - LzContext *lz = dcc->lz; + LzData *lz_data = &dcc->priv->lz_data; + LzContext *lz = dcc->priv->lz; LzImageType type = bitmap_fmt_to_lz_image_type[src->format]; int size; // size of the compressed data @@ -775,10 +934,10 @@ int dcc_compress_image_jpeg(DisplayChannelClient *dcc, SpiceImage *dest, SpiceBitmap *src, compress_send_data_t* o_comp_data, uint32_t group_id) { - JpegData *jpeg_data = &dcc->jpeg_data; - LzData *lz_data = &dcc->lz_data; - JpegEncoderContext *jpeg = dcc->jpeg; - LzContext *lz = dcc->lz; + JpegData *jpeg_data = &dcc->priv->jpeg_data; + LzData *lz_data = &dcc->priv->lz_data; + JpegEncoderContext *jpeg = dcc->priv->jpeg; + LzContext *lz = dcc->priv->lz; volatile JpegEncoderImageType jpeg_in_type; int jpeg_size = 0; volatile int has_alpha = FALSE; @@ -838,7 +997,7 @@ int dcc_compress_image_jpeg(DisplayChannelClient *dcc, SpiceImage *dest, jpeg_data->data.u.lines_data.reverse = 1; stride = -src->stride; } - jpeg_size = jpeg_encode(jpeg, dcc->jpeg_quality, jpeg_in_type, + jpeg_size = jpeg_encode(jpeg, dcc->priv->jpeg_quality, jpeg_in_type, src->x, src->y, NULL, 0, stride, jpeg_data->data.bufs_head->buf, sizeof(jpeg_data->data.bufs_head->buf)); @@ -974,8 +1133,8 @@ int dcc_compress_image_quic(DisplayChannelClient *dcc, SpiceImage *dest, SpiceBitmap *src, compress_send_data_t* o_comp_data, uint32_t group_id) { - QuicData *quic_data = &dcc->quic_data; - QuicContext *quic = dcc->quic; + QuicData *quic_data = &dcc->priv->quic_data; + QuicContext *quic = dcc->priv->quic; volatile QuicImageType type; int size, stride; @@ -1057,7 +1216,7 @@ int dcc_compress_image(DisplayChannelClient *dcc, compress_send_data_t* o_comp_data) { DisplayChannel *display_channel = DCC_TO_DC(dcc); - spice_image_compression_t image_compression = dcc->image_compression; + spice_image_compression_t image_compression = dcc->priv->image_compression; int quic_compress = FALSE; if ((image_compression == SPICE_IMAGE_COMPRESS_OFF) || @@ -1125,7 +1284,7 @@ int dcc_compress_image(DisplayChannelClient *dcc, (image_compression == SPICE_IMAGE_COMPRESS_GLZ)) { glz = bitmap_fmt_has_graduality(src->format) && ( (src->x * src->y) < glz_enc_dictionary_get_size( - dcc->glz_dict->dict)); + dcc->priv->glz_dict->dict)); } else if ((image_compression == SPICE_IMAGE_COMPRESS_AUTO_LZ) || (image_compression == SPICE_IMAGE_COMPRESS_LZ) || (image_compression == SPICE_IMAGE_COMPRESS_LZ4)) { @@ -1137,22 +1296,22 @@ int dcc_compress_image(DisplayChannelClient *dcc, if (glz) { /* using the global dictionary only if it is not frozen */ - pthread_rwlock_rdlock(&dcc->glz_dict->encode_lock); - if (!dcc->glz_dict->migrate_freeze) { + pthread_rwlock_rdlock(&dcc->priv->glz_dict->encode_lock); + if (!dcc->priv->glz_dict->migrate_freeze) { ret = dcc_compress_image_glz(dcc, dest, src, drawable, o_comp_data); } else { glz = FALSE; } - pthread_rwlock_unlock(&dcc->glz_dict->encode_lock); + pthread_rwlock_unlock(&dcc->priv->glz_dict->encode_lock); } if (!glz) { #ifdef USE_LZ4 if (image_compression == SPICE_IMAGE_COMPRESS_LZ4 && bitmap_fmt_is_rgb(src->format) && - red_channel_client_test_remote_cap(&dcc->common.base, + red_channel_client_test_remote_cap(&dcc->priv->common.base, SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) { ret = dcc_compress_image_lz4(dcc, dest, src, o_comp_data, drawable->group_id); @@ -1202,7 +1361,7 @@ void dcc_palette_cache_reset(DisplayChannelClient *dcc) static void dcc_push_release(DisplayChannelClient *dcc, uint8_t type, uint64_t id, uint64_t* sync_data) { - FreeList *free_list = &dcc->send_data.free_list; + FreeList *free_list = &dcc->priv->send_data.free_list; int i; for (i = 0; i < MAX_CACHE_CLIENTS; i++) { @@ -1226,10 +1385,11 @@ static void dcc_push_release(DisplayChannelClient *dcc, uint8_t type, uint64_t i int dcc_pixmap_cache_add(DisplayChannelClient *dcc, uint64_t id, uint32_t size, int lossy) { - PixmapCache *cache = dcc->pixmap_cache; + PixmapCache *cache = dcc->priv->pixmap_cache; NewCacheItem *item; uint64_t serial; int key; + uint32_t client_id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); spice_return_val_if_fail(size > 0, FALSE); @@ -1238,11 +1398,11 @@ int dcc_pixmap_cache_add(DisplayChannelClient *dcc, uint64_t id, uint32_t size, pthread_mutex_lock(&cache->lock); - if (cache->generation != dcc->pixmap_cache_generation) { - if (!dcc->pending_pixmaps_sync) { + if (cache->generation != dcc->priv->pixmap_cache_generation) { + if (!dcc->priv->pending_pixmaps_sync) { red_channel_client_pipe_add_type( RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_SYNC); - dcc->pending_pixmaps_sync = TRUE; + dcc->priv->pending_pixmaps_sync = TRUE; } pthread_mutex_unlock(&cache->lock); free(item); @@ -1255,7 +1415,7 @@ int dcc_pixmap_cache_add(DisplayChannelClient *dcc, uint64_t id, uint32_t size, NewCacheItem **now; if (!(tail = (NewCacheItem *)ring_get_tail(&cache->lru)) || - tail->sync[dcc->common.id] == serial) { + tail->sync[client_id] == serial) { cache->available += size; pthread_mutex_unlock(&cache->lock); free(item); @@ -1274,7 +1434,7 @@ int dcc_pixmap_cache_add(DisplayChannelClient *dcc, uint64_t id, uint32_t size, ring_remove(&tail->lru_link); cache->items--; cache->available += tail->size; - cache->sync[dcc->common.id] = serial; + cache->sync[client_id] = serial; dcc_push_release(dcc, SPICE_RES_TYPE_PIXMAP, tail->id, tail->sync); free(tail); } @@ -1287,31 +1447,32 @@ int dcc_pixmap_cache_add(DisplayChannelClient *dcc, uint64_t id, uint32_t size, item->size = size; item->lossy = lossy; memset(item->sync, 0, sizeof(item->sync)); - item->sync[dcc->common.id] = serial; - cache->sync[dcc->common.id] = serial; + item->sync[client_id] = serial; + cache->sync[client_id] = serial; pthread_mutex_unlock(&cache->lock); return TRUE; } static int dcc_handle_init(DisplayChannelClient *dcc, SpiceMsgcDisplayInit *init) { - spice_return_val_if_fail(dcc->expect_init, FALSE); - dcc->expect_init = FALSE; + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); + spice_return_val_if_fail(dcc->priv->expect_init, FALSE); + dcc->priv->expect_init = FALSE; - spice_return_val_if_fail(!dcc->pixmap_cache, FALSE); - dcc->pixmap_cache = pixmap_cache_get(RED_CHANNEL_CLIENT(dcc)->client, + spice_return_val_if_fail(!dcc->priv->pixmap_cache, FALSE); + dcc->priv->pixmap_cache = pixmap_cache_get(client, init->pixmap_cache_id, init->pixmap_cache_size); - spice_return_val_if_fail(dcc->pixmap_cache, FALSE); + spice_return_val_if_fail(dcc->priv->pixmap_cache, FALSE); - spice_return_val_if_fail(!dcc->glz_dict, FALSE); - ring_init(&dcc->glz_drawables); - ring_init(&dcc->glz_drawables_inst_to_free); - pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL); - dcc->glz_dict = get_glz_dictionary_for_dcc(dcc, + spice_return_val_if_fail(!dcc->priv->glz_dict, FALSE); + ring_init(&dcc->priv->glz_drawables); + ring_init(&dcc->priv->glz_drawables_inst_to_free); + pthread_mutex_init(&dcc->priv->glz_drawables_inst_to_free_lock, NULL); + dcc->priv->glz_dict = get_glz_dictionary_for_dcc(dcc, init->glz_dictionary_id, init->glz_dictionary_window_size); - spice_return_val_if_fail(dcc->glz_dict, FALSE); + spice_return_val_if_fail(dcc->priv->glz_dict, FALSE); return TRUE; } @@ -1322,7 +1483,7 @@ static int dcc_handle_stream_report(DisplayChannelClient *dcc, StreamAgent *agent; spice_return_val_if_fail(report->stream_id < NUM_STREAMS, FALSE); - agent = &dcc->stream_agents[report->stream_id]; + agent = &dcc->priv->stream_agents[report->stream_id]; spice_return_val_if_fail(agent->mjpeg_encoder, TRUE); spice_return_val_if_fail(report->unique_id == agent->report_id, TRUE); @@ -1338,7 +1499,7 @@ static int dcc_handle_stream_report(DisplayChannelClient *dcc, int dcc_handle_message(RedChannelClient *rcc, uint32_t size, uint16_t type, void *msg) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); switch (type) { case SPICE_MSGC_DISPLAY_INIT: @@ -1353,26 +1514,26 @@ int dcc_handle_message(RedChannelClient *rcc, uint32_t size, uint16_t type, void static int dcc_handle_migrate_glz_dictionary(DisplayChannelClient *dcc, SpiceMigrateDataDisplay *migrate) { - spice_return_val_if_fail(!dcc->glz_dict, FALSE); + spice_return_val_if_fail(!dcc->priv->glz_dict, FALSE); - ring_init(&dcc->glz_drawables); - ring_init(&dcc->glz_drawables_inst_to_free); - pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL); - dcc->glz_dict = restore_glz_dictionary_for_dcc(dcc, + ring_init(&dcc->priv->glz_drawables); + ring_init(&dcc->priv->glz_drawables_inst_to_free); + pthread_mutex_init(&dcc->priv->glz_drawables_inst_to_free_lock, NULL); + dcc->priv->glz_dict = restore_glz_dictionary_for_dcc(dcc, migrate->glz_dict_id, &migrate->glz_dict_data); - return dcc->glz_dict != NULL; + return dcc->priv->glz_dict != NULL; } static int restore_surface(DisplayChannelClient *dcc, uint32_t surface_id) { /* we don't process commands till we receive the migration data, thus, * we should have not sent any surface to the client. */ - if (dcc->surface_client_created[surface_id]) { + if (dcc->priv->surface_client_created[surface_id]) { spice_warning("surface %u is already marked as client_created", surface_id); return FALSE; } - dcc->surface_client_created[surface_id] = TRUE; + dcc->priv->surface_client_created[surface_id] = TRUE; return TRUE; } @@ -1410,14 +1571,15 @@ static int restore_surfaces_lossy(DisplayChannelClient *dcc, lossy_rect.top = mig_lossy_rect->top; lossy_rect.right = mig_lossy_rect->right; lossy_rect.bottom = mig_lossy_rect->bottom; - region_init(&dcc->surface_client_lossy_region[surface_id]); - region_add(&dcc->surface_client_lossy_region[surface_id], &lossy_rect); + region_init(&dcc->priv->surface_client_lossy_region[surface_id]); + region_add(&dcc->priv->surface_client_lossy_region[surface_id], &lossy_rect); } return TRUE; } int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *message) { + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)); DisplayChannel *display = DCC_TO_DC(dcc); int surfaces_restored = FALSE; SpiceMigrateDataHeader *header = (SpiceMigrateDataHeader *)message; @@ -1435,39 +1597,41 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess * channel client that froze the cache on the src size receives the migrate * data and unfreezes the cache by setting its size > 0 and by triggering * pixmap_cache_reset */ - dcc->pixmap_cache = pixmap_cache_get(RED_CHANNEL_CLIENT(dcc)->client, - migrate_data->pixmap_cache_id, -1); - spice_return_val_if_fail(dcc->pixmap_cache, FALSE); + dcc->priv->pixmap_cache = pixmap_cache_get(client, + migrate_data->pixmap_cache_id, -1); + spice_return_val_if_fail(dcc->priv->pixmap_cache, FALSE); - pthread_mutex_lock(&dcc->pixmap_cache->lock); + pthread_mutex_lock(&dcc->priv->pixmap_cache->lock); for (i = 0; i < MAX_CACHE_CLIENTS; i++) { - dcc->pixmap_cache->sync[i] = MAX(dcc->pixmap_cache->sync[i], + dcc->priv->pixmap_cache->sync[i] = MAX(dcc->priv->pixmap_cache->sync[i], migrate_data->pixmap_cache_clients[i]); } - pthread_mutex_unlock(&dcc->pixmap_cache->lock); + pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock); 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 */ - dcc->pixmap_cache->size = migrate_data->pixmap_cache_size; + dcc->priv->pixmap_cache->size = migrate_data->pixmap_cache_size; red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_RESET); } if (dcc_handle_migrate_glz_dictionary(dcc, migrate_data)) { - dcc->glz = - glz_encoder_create(dcc->common.id, dcc->glz_dict->dict, &dcc->glz_data.usr); + uint32_t id = common_worker_channel_client_get_id(COMMON_WORKER_CHANNEL_CLIENT(dcc)); + dcc->priv->glz = + glz_encoder_create(id, dcc->priv->glz_dict->dict, &dcc->priv->glz_data.usr); } else { spice_critical("restoring global lz dictionary failed"); } - dcc->common.is_low_bandwidth = migrate_data->low_bandwidth_setting; + common_worker_channel_client_set_low_bandwidth(COMMON_WORKER_CHANNEL_CLIENT(dcc), + migrate_data->low_bandwidth_setting); if (migrate_data->low_bandwidth_setting) { red_channel_client_ack_set_client_window(RED_CHANNEL_CLIENT(dcc), WIDE_CLIENT_ACK_WINDOW); - if (dcc->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) { + if (dcc->priv->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) { display->enable_jpeg = TRUE; } - if (dcc->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) { + if (dcc->priv->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) { display->enable_zlib_glz_wrap = TRUE; } } @@ -1610,46 +1774,46 @@ void dcc_release_item(DisplayChannelClient *dcc, PipeItem *item, int item_pushed StreamAgent* dcc_get_stream_agent(DisplayChannelClient *dcc, int stream_id) { - return &dcc->stream_agents[stream_id]; + return &dcc->priv->stream_agents[stream_id]; } GlzSharedDictionary* dcc_get_glz_dictionary(DisplayChannelClient *dcc) { - return dcc->glz_dict; + return dcc->priv->glz_dict; } spice_wan_compression_t dcc_get_jpeg_state(DisplayChannelClient *dcc) { - return dcc->jpeg_state; + return dcc->priv->jpeg_state; } spice_wan_compression_t dcc_get_zlib_glz_state(DisplayChannelClient *dcc) { - return dcc->zlib_glz_state; + return dcc->priv->zlib_glz_state; } gboolean dcc_use_mjpeg_encoder_rate_control(DisplayChannelClient *dcc) { - return dcc->use_mjpeg_encoder_rate_control; + return dcc->priv->use_mjpeg_encoder_rate_control; } uint32_t dcc_get_max_stream_latency(DisplayChannelClient *dcc) { - return dcc->streams_max_latency; + return dcc->priv->streams_max_latency; } void dcc_set_max_stream_latency(DisplayChannelClient *dcc, uint32_t latency) { - dcc->streams_max_latency = latency; + dcc->priv->streams_max_latency = latency; } uint64_t dcc_get_max_stream_bit_rate(DisplayChannelClient *dcc) { - return dcc->streams_max_bit_rate; + return dcc->priv->streams_max_bit_rate; } void dcc_set_max_stream_bit_rate(DisplayChannelClient *dcc, uint64_t rate) { - dcc->streams_max_bit_rate = rate; + dcc->priv->streams_max_bit_rate = rate; } diff --git a/server/dcc.h b/server/dcc.h index 07b7afe0..be7db9f0 100644 --- a/server/dcc.h +++ b/server/dcc.h @@ -18,10 +18,39 @@ #ifndef DCC_H_ # define DCC_H_ +#include <glib-object.h> #include "image-cache.h" #include "pixmap-cache.h" #include "red-worker.h" +G_BEGIN_DECLS + +#define TYPE_DISPLAY_CHANNEL_CLIENT display_channel_client_get_type() + +#define DISPLAY_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_DISPLAY_CHANNEL_CLIENT, DisplayChannelClient)) +#define DISPLAY_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_DISPLAY_CHANNEL_CLIENT, DisplayChannelClientClass)) +#define IS_DISPLAY_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_DISPLAY_CHANNEL_CLIENT)) +#define IS_DISPLAY_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_DISPLAY_CHANNEL_CLIENT)) +#define DISPLAY_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_DISPLAY_CHANNEL_CLIENT, DisplayChannelClientClass)) + +typedef struct _DisplayChannelClient DisplayChannelClient; +typedef struct _DisplayChannelClientClass DisplayChannelClientClass; +typedef struct _DisplayChannelClientPrivate DisplayChannelClientPrivate; + +struct _DisplayChannelClient +{ + CommonWorkerChannelClient parent; + + DisplayChannelClientPrivate *priv; +}; + +struct _DisplayChannelClientClass +{ + CommonWorkerChannelClientClass parent_class; +}; + +GType display_channel_client_get_type(void) G_GNUC_CONST; + #define PALETTE_CACHE_HASH_SHIFT 8 #define PALETTE_CACHE_HASH_SIZE (1 << PALETTE_CACHE_HASH_SHIFT) #define PALETTE_CACHE_HASH_MASK (PALETTE_CACHE_HASH_SIZE - 1) @@ -59,11 +88,8 @@ typedef struct FreeList { WaitForChannels wait; } FreeList; -typedef struct _DisplayChannelClient DisplayChannelClient; - #define DCC_TO_WORKER(dcc) ((RedWorker*)((CommonWorkerChannel*)(red_channel_client_get_channel((RedChannelClient*)dcc)))->worker) #define DCC_TO_DC(dcc) ((DisplayChannel*)red_channel_client_get_channel((RedChannelClient*)dcc)) -#define RCC_TO_DCC(rcc) ((DisplayChannelClient*)rcc) typedef struct SurfaceCreateItem { SpiceMsgSurfaceCreate surface_create; @@ -187,4 +213,6 @@ void dcc_set_max_stream_latency(DisplayChannelClient *dcc, uint32_t latency); uint64_t dcc_get_max_stream_bit_rate(DisplayChannelClient *dcc); void dcc_set_max_stream_bit_rate(DisplayChannelClient *dcc, uint64_t rate); +G_END_DECLS + #endif /* DCC_H_ */ diff --git a/server/display-channel.c b/server/display-channel.c index 687406db..9ac482c0 100644 --- a/server/display-channel.c +++ b/server/display-channel.c @@ -1866,7 +1866,7 @@ void display_channel_create_surface(DisplayChannel *display, uint32_t surface_id static void on_disconnect(RedChannelClient *rcc) { DisplayChannel *display; - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedWorker *worker; spice_info(NULL); @@ -1890,7 +1890,7 @@ static void on_disconnect(RedChannelClient *rcc) static void send_item(RedChannelClient *rcc, PipeItem *item) { - dcc_send_item(RCC_TO_DCC(rcc), item); + dcc_send_item(DISPLAY_CHANNEL_CLIENT(rcc), item); } static void hold_item(RedChannelClient *rcc, PipeItem *item) @@ -1917,7 +1917,7 @@ static void hold_item(RedChannelClient *rcc, PipeItem *item) static void release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed) { - DisplayChannelClient *dcc = RCC_TO_DCC(rcc); + DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc); RedWorker *worker = DCC_TO_WORKER(dcc); spice_return_if_fail(item != NULL); @@ -1944,7 +1944,7 @@ static uint64_t handle_migrate_data_get_serial(RedChannelClient *rcc, uint32_t s static int handle_migrate_data(RedChannelClient *rcc, uint32_t size, void *message) { - return dcc_handle_migrate_data(RCC_TO_DCC(rcc), size, message); + return dcc_handle_migrate_data(DISPLAY_CHANNEL_CLIENT(rcc), size, message); } static SpiceCanvas *image_surfaces_get(SpiceImageSurfaces *surfaces, uint32_t surface_id) @@ -2064,7 +2064,7 @@ void display_channel_process_surface_cmd(DisplayChannel *display, RedSurfaceCmd void display_channel_update_compression(DisplayChannel *display, DisplayChannelClient *dcc) { - gboolean is_low_bw = common_worker_channel_client_is_low_bandwidth((CommonWorkerChannelClient*)dcc); + gboolean is_low_bw = common_worker_channel_client_is_low_bandwidth(COMMON_WORKER_CHANNEL_CLIENT(dcc)); if (dcc_get_jpeg_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) { display->enable_jpeg = is_low_bw; } else { diff --git a/server/dummy-channel-client.c b/server/dummy-channel-client.c new file mode 100644 index 00000000..0669ee40 --- /dev/null +++ b/server/dummy-channel-client.c @@ -0,0 +1,154 @@ +/* + Copyright (C) 2009-2015 Red Hat, Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see <http://www.gnu.org/licenses/>. +*/ + +#include "dummy-channel-client.h" +#include "red-channel.h" + +static void dummy_channel_client_initable_interface_init(GInitableIface *iface); + +G_DEFINE_TYPE_WITH_CODE(DummyChannelClient, dummy_channel_client, RED_TYPE_CHANNEL_CLIENT, + G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, + dummy_channel_client_initable_interface_init)) + +#define DUMMY_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_DUMMY_CHANNEL_CLIENT, DummyChannelClientPrivate)) + +struct _DummyChannelClientPrivate +{ + gboolean connected; +}; + +static int dummy_channel_client_pre_create_validate(RedChannel *channel, RedClient *client) +{ + if (red_client_get_channel(client, channel->type, channel->id)) { + spice_printerr("Error client %p: duplicate channel type %d id %d", + client, channel->type, channel->id); + return FALSE; + } + return TRUE; +} + +static gboolean dummy_channel_client_initable_init(GInitable *initable, + GCancellable *cancellable, + GError **error) +{ + GError *local_error = NULL; + DummyChannelClient *self = DUMMY_CHANNEL_CLIENT(initable); + RedChannelClient *rcc = RED_CHANNEL_CLIENT(self); + RedClient *client = red_channel_client_get_client(rcc); + RedChannel *channel = red_channel_client_get_channel(rcc); + pthread_mutex_lock(&client->lock); + if (!dummy_channel_client_pre_create_validate(channel, + client)) { + g_set_error(&local_error, + SPICE_SERVER_ERROR, + SPICE_SERVER_ERROR_FAILED, + "Client %p: duplicate channel type %d id %d", + client, channel->type, channel->id); + goto cleanup; + } + + rcc->incoming.header.data = rcc->incoming.header_buf; + rcc->incoming.serial = 1; + + red_channel_add_client(channel, rcc); + red_client_add_channel(client, rcc); + +cleanup: + pthread_mutex_unlock(&client->lock); + if (local_error) { + g_warning("Failed to create channel client: %s", local_error->message); + g_propagate_error(error, local_error); + } + return local_error == NULL; +} + +static void dummy_channel_client_initable_interface_init(GInitableIface *iface) +{ + iface->init = dummy_channel_client_initable_init; +} + +gboolean dummy_channel_client_is_connected(RedChannelClient *rcc) +{ + return DUMMY_CHANNEL_CLIENT(rcc)->priv->connected; +} + +void dummy_channel_client_disconnect(RedChannelClient *rcc) +{ + DummyChannelClient *self = DUMMY_CHANNEL_CLIENT(rcc); + RedChannel *channel = red_channel_client_get_channel(rcc); + GList *link; + + if (channel && (link = g_list_find(channel->clients, rcc))) { + spice_printerr("rcc=%p (channel=%p type=%d id=%d)", rcc, channel, + channel->type, channel->id); + red_channel_remove_client(channel, link->data); + } + self->priv->connected = FALSE; +} + +static void +dummy_channel_client_class_init(DummyChannelClientClass *klass) +{ + RedChannelClientClass *cc_class = RED_CHANNEL_CLIENT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(DummyChannelClientPrivate)); + + cc_class->is_connected = dummy_channel_client_is_connected; + cc_class->disconnect = dummy_channel_client_disconnect; +} + +static void +dummy_channel_client_init(DummyChannelClient *self) +{ + self->priv = DUMMY_CHANNEL_CLIENT_PRIVATE(self); + + self->priv->connected = TRUE; +} + +RedChannelClient* dummy_channel_client_create(RedChannel *channel, + RedClient *client, + int num_common_caps, + uint32_t *common_caps, + int num_caps, uint32_t *caps) +{ + RedChannelClient *rcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); + } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + + rcc = g_initable_new(TYPE_DUMMY_CHANNEL_CLIENT, + NULL, NULL, + "channel", channel, + "client", client, + "caps", caps_array, + "common-caps", common_caps_array, + NULL); + + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); + + return rcc; +} diff --git a/server/dummy-channel-client.h b/server/dummy-channel-client.h new file mode 100644 index 00000000..79efd662 --- /dev/null +++ b/server/dummy-channel-client.h @@ -0,0 +1,58 @@ +/* + Copyright (C) 2009-2015 Red Hat, Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see <http://www.gnu.org/licenses/>. + */ +#ifndef __DUMMY_CHANNEL_CLIENT_H__ +#define __DUMMY_CHANNEL_CLIENT_H__ + +#include <glib-object.h> +#include "red-channel-client.h" + +G_BEGIN_DECLS + +#define TYPE_DUMMY_CHANNEL_CLIENT dummy_channel_client_get_type() + +#define DUMMY_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DUMMY_CHANNEL_CLIENT, DummyChannelClient)) +#define DUMMY_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DUMMY_CHANNEL_CLIENT, DummyChannelClientClass)) +#define IS_DUMMY_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DUMMY_CHANNEL_CLIENT)) +#define IS_DUMMY_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DUMMY_CHANNEL_CLIENT)) +#define DUMMY_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DUMMY_CHANNEL_CLIENT, DummyChannelClientClass)) + +typedef struct _DummyChannelClient DummyChannelClient; +typedef struct _DummyChannelClientClass DummyChannelClientClass; +typedef struct _DummyChannelClientPrivate DummyChannelClientPrivate; + +struct _DummyChannelClient +{ + RedChannelClient parent; + + DummyChannelClientPrivate *priv; +}; + +struct _DummyChannelClientClass +{ + RedChannelClientClass parent_class; +}; + +GType dummy_channel_client_get_type(void) G_GNUC_CONST; + +RedChannelClient *dummy_channel_client_create(RedChannel *channel, + RedClient *client, + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps); + +G_END_DECLS + +#endif /* __DUMMY_CHANNEL_CLIENT_H__ */ diff --git a/server/inputs-channel-client.c b/server/inputs-channel-client.c index bef974e6..c25f60f4 100644 --- a/server/inputs-channel-client.c +++ b/server/inputs-channel-client.c @@ -16,15 +16,31 @@ */ #include "inputs-channel-client.h" -#include "inputs-channel.h" #include "migration-protocol.h" #include "red-channel-client-private.h" -struct InputsChannelClient { - RedChannelClient base; +G_DEFINE_TYPE(InputsChannelClient, inputs_channel_client, RED_TYPE_CHANNEL_CLIENT) + +#define INPUTS_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_INPUTS_CHANNEL_CLIENT, InputsChannelClientPrivate)) + +struct _InputsChannelClientPrivate +{ uint16_t motion_count; }; +static void +inputs_channel_client_class_init(InputsChannelClientClass *klass) +{ + g_type_class_add_private(klass, sizeof(InputsChannelClientPrivate)); +} + +static void +inputs_channel_client_init(InputsChannelClient *self) +{ + self->priv = INPUTS_CHANNEL_CLIENT_PRIVATE(self); + self->priv->motion_count = 0; +} + InputsChannelClient* inputs_channel_client_create(RedChannel *channel, RedClient *client, RedsStream *stream, @@ -34,57 +50,71 @@ InputsChannelClient* inputs_channel_client_create(RedChannel *channel, int num_caps, uint32_t *caps) { - InputsChannelClient* icc = - (InputsChannelClient*)red_channel_client_create(sizeof(InputsChannelClient), - channel, client, - stream, - monitor_latency, - num_common_caps, - common_caps, num_caps, - caps); - if (icc) - icc->motion_count = 0; - return icc; + InputsChannelClient *rcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); + } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + rcc = g_initable_new(TYPE_INPUTS_CHANNEL_CLIENT, + NULL, NULL, + "channel", channel, + "client", client, + "stream", stream, + "monitor-latency", monitor_latency, + "caps", caps_array, + "common-caps", common_caps_array, + NULL); + + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); + + return rcc; + } void inputs_channel_client_send_migrate_data(RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item) { - InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base); - InputsChannel *inputs = (InputsChannel*)rcc->channel; + InputsChannelClient *icc = INPUTS_CHANNEL_CLIENT(rcc); + InputsChannel *inputs = (InputsChannel*)red_channel_client_get_channel(rcc); inputs_channel_set_src_during_migrate(inputs, FALSE); red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item); spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_MAGIC); spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_VERSION); - spice_marshaller_add_uint16(m, icc->motion_count); + spice_marshaller_add_uint16(m, icc->priv->motion_count); } void inputs_channel_client_handle_migrate_data(InputsChannelClient *icc, uint16_t motion_count) { - icc->motion_count = motion_count; + icc->priv->motion_count = motion_count; - for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH; - icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) { - red_channel_client_pipe_add_type(&icc->base, PIPE_ITEM_MOUSE_MOTION_ACK); + for (; icc->priv->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH; + icc->priv->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) { + red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(icc), + PIPE_ITEM_MOUSE_MOTION_ACK); } } void inputs_channel_client_on_mouse_motion(InputsChannelClient *icc) { - InputsChannel *inputs_channel = (InputsChannel *)icc->base.channel; + InputsChannel *inputs_channel = (InputsChannel *)red_channel_client_get_channel(RED_CHANNEL_CLIENT(icc)); - if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 && + if (++icc->priv->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 && !inputs_channel_is_src_during_migrate(inputs_channel)) { - red_channel_client_pipe_add_type(&icc->base, PIPE_ITEM_MOUSE_MOTION_ACK); - icc->motion_count = 0; + red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(icc), + PIPE_ITEM_MOUSE_MOTION_ACK); + icc->priv->motion_count = 0; } } - -RedChannelClient* inputs_channel_client_get_base(InputsChannelClient* icc) -{ - return &icc->base; -} diff --git a/server/inputs-channel-client.h b/server/inputs-channel-client.h index c999e52d..af29ea10 100644 --- a/server/inputs-channel-client.h +++ b/server/inputs-channel-client.h @@ -13,32 +13,57 @@ You should have received a copy of the GNU Lesser General Public License along with this library; if not, see <http://www.gnu.org/licenses/>. -*/ + */ #ifndef _INPUTS_CHANNEL_CLIENT_H_ #define _INPUTS_CHANNEL_CLIENT_H_ -#include "red-channel.h" +#include <glib-object.h> +#include "red-channel-client.h" +#include "inputs-channel.h" -typedef struct InputsChannelClient InputsChannelClient; +G_BEGIN_DECLS -InputsChannelClient* inputs_channel_client_create(RedChannel *channel, +#define TYPE_INPUTS_CHANNEL_CLIENT inputs_channel_client_get_type() + +#define INPUTS_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_INPUTS_CHANNEL_CLIENT, InputsChannelClient)) +#define INPUTS_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_INPUTS_CHANNEL_CLIENT, InputsChannelClientClass)) +#define IS_INPUTS_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_INPUTS_CHANNEL_CLIENT)) +#define IS_INPUTS_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_INPUTS_CHANNEL_CLIENT)) +#define INPUTS_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_INPUTS_CHANNEL_CLIENT, InputsChannelClientClass)) + +typedef struct _InputsChannelClient InputsChannelClient; +typedef struct _InputsChannelClientClass InputsChannelClientClass; +typedef struct _InputsChannelClientPrivate InputsChannelClientPrivate; + +struct _InputsChannelClient +{ + RedChannelClient parent; + + InputsChannelClientPrivate *priv; +}; + +struct _InputsChannelClientClass +{ + RedChannelClientClass parent_class; +}; + +GType inputs_channel_client_get_type(void) G_GNUC_CONST; + +InputsChannelClient *inputs_channel_client_create(RedChannel *channel, RedClient *client, RedsStream *stream, int monitor_latency, - int num_common_caps, - uint32_t *common_caps, - int num_caps, - uint32_t *caps); - -void inputs_channel_client_send_migrate_data(RedChannelClient *rcc, - SpiceMarshaller *m, - PipeItem *item); -void inputs_channel_client_handle_migrate_data(InputsChannelClient *icc, - uint16_t motion_count); -void inputs_channel_client_on_mouse_motion(InputsChannelClient *icc); - -/* FIXME: temporary until GObjectification */ -RedChannelClient* inputs_channel_client_get_base(InputsChannelClient* icc); + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps); + +uint16_t inputs_channel_client_get_motion_count(InputsChannelClient* self); +/* only for migration */ +void inputs_channel_client_set_motion_count(InputsChannelClient* self, uint16_t count); +void inputs_channel_client_on_mouse_motion(InputsChannelClient* self); +void inputs_channel_client_send_migrate_data(RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item); +void inputs_channel_client_handle_migrate_data(InputsChannelClient *icc, uint16_t motion_count); + +G_END_DECLS #endif /* _INPUTS_CHANNEL_CLIENT_H_ */ diff --git a/server/inputs-channel.c b/server/inputs-channel.c index f7884cba..ba40cd67 100644 --- a/server/inputs-channel.c +++ b/server/inputs-channel.c @@ -281,7 +281,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui void *message) { InputsChannel *inputs_channel = (InputsChannel *)red_channel_client_get_channel(rcc); - InputsChannelClient *icc = (InputsChannelClient *)rcc; + InputsChannelClient *icc = INPUTS_CHANNEL_CLIENT(rcc); uint32_t i; RedsState *reds = red_channel_get_server((RedChannel*)inputs_channel); @@ -518,7 +518,7 @@ static void inputs_connect(RedChannel *channel, RedClient *client, if (!icc) { return; } - inputs_pipe_add_init(inputs_channel_client_get_base(icc)); + inputs_pipe_add_init(RED_CHANNEL_CLIENT(icc)); } static void inputs_migrate(RedChannelClient *rcc) @@ -559,7 +559,7 @@ static int inputs_channel_handle_migrate_data(RedChannelClient *rcc, uint32_t size, void *message) { - InputsChannelClient *icc = (InputsChannelClient*)rcc; + InputsChannelClient *icc = INPUTS_CHANNEL_CLIENT(rcc); InputsChannel *inputs = (InputsChannel*)red_channel_client_get_channel(rcc); SpiceMigrateDataHeader *header; SpiceMigrateDataInputs *mig_data; diff --git a/server/inputs-channel.h b/server/inputs-channel.h index c84e7906..27a6fc7b 100644 --- a/server/inputs-channel.h +++ b/server/inputs-channel.h @@ -24,6 +24,8 @@ #include <stdint.h> #include <spice/vd_agent.h> +#include "red-channel.h" + typedef struct InputsChannel InputsChannel; InputsChannel* inputs_channel_new(RedsState *reds); diff --git a/server/main-channel-client.c b/server/main-channel-client.c index 73396f24..7d91ac13 100644 --- a/server/main-channel-client.c +++ b/server/main-channel-client.c @@ -16,6 +16,7 @@ */ #include <inttypes.h> + #include "main-channel-client.h" #include "main-channel.h" #include "red-channel-client-private.h" @@ -35,8 +36,11 @@ enum NetTestStage { #define CLIENT_CONNECTIVITY_TIMEOUT (30*1000) // 30 seconds #define PING_INTERVAL (1000 * 10) -struct MainChannelClient { - RedChannelClient base; +G_DEFINE_TYPE(MainChannelClient, main_channel_client, RED_TYPE_CHANNEL_CLIENT) + +#define MAIN_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_MAIN_CHANNEL_CLIENT, MainChannelClientPrivate)) + +struct _MainChannelClientPrivate { uint32_t connection_id; uint32_t ping_id; uint32_t net_test_id; @@ -55,6 +59,101 @@ struct MainChannelClient { int seamless_mig_dst; }; +enum { + PROP0, + PROP_CONNECTION_ID +}; + +static void main_channel_client_get_property(GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + MainChannelClient *self = MAIN_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_CONNECTION_ID: + g_value_set_uint(value, self->priv->connection_id); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void main_channel_client_set_property(GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + MainChannelClient *self = MAIN_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_CONNECTION_ID: + self->priv->connection_id = g_value_get_uint(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void main_channel_client_dispose(GObject *object) +{ + G_OBJECT_CLASS(main_channel_client_parent_class)->dispose(object); +} + +static void main_channel_client_finalize(GObject *object) +{ + G_OBJECT_CLASS(main_channel_client_parent_class)->finalize(object); +} + +static void ping_timer_cb(void *opaque); +static void main_channel_client_constructed(GObject *object) +{ + G_OBJECT_CLASS(main_channel_client_parent_class)->constructed(object); +#ifdef RED_STATISTICS + MainChannelClient *self = MAIN_CHANNEL_CLIENT(object); + RedsState *reds = red_channel_get_server(red_channel_client_get_channel(RED_CHANNEL_CLIENT(object))); + + if (!(self->priv->ping_timer = reds_get_core_interface(reds)->timer_add(ping_timer_cb, NULL))) { + spice_error("ping timer create failed"); + } + self->priv->ping_interval = PING_INTERVAL; +#endif +} + +static void main_channel_client_class_init(MainChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(MainChannelClientPrivate)); + + object_class->get_property = main_channel_client_get_property; + object_class->set_property = main_channel_client_set_property; + object_class->dispose = main_channel_client_dispose; + object_class->finalize = main_channel_client_finalize; + object_class->constructed = main_channel_client_constructed; + + g_object_class_install_property(object_class, + PROP_CONNECTION_ID, + g_param_spec_uint("connection-id", + "Connection ID", + "Connection ID", + 0, + G_MAXUINT, + 0, + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); +} + +static void main_channel_client_init(MainChannelClient *self) +{ + self->priv = MAIN_CHANNEL_CLIENT_PRIVATE(self); + self->priv->bitrate_per_sec = ~0; +} + PipeItem *main_notify_item_new(void *data, int num) { NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem)); @@ -67,18 +166,19 @@ PipeItem *main_notify_item_new(void *data, int num) void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate) { - if (!mcc || mcc->net_test_id) { + if (!mcc || mcc->priv->net_test_id) { return; } if (test_rate) { if (main_channel_client_push_ping(mcc, NET_TEST_WARMUP_BYTES) && main_channel_client_push_ping(mcc, 0) && main_channel_client_push_ping(mcc, NET_TEST_BYTES)) { - mcc->net_test_id = mcc->ping_id - 2; - mcc->net_test_stage = NET_TEST_STAGE_WARMUP; + mcc->priv->net_test_id = mcc->priv->ping_id - 2; + mcc->priv->net_test_stage = NET_TEST_STAGE_WARMUP; } } else { - red_channel_client_start_connectivity_monitoring(&mcc->base, CLIENT_CONNECTIVITY_TIMEOUT); + red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc), + CLIENT_CONNECTIVITY_TIMEOUT); } } @@ -99,7 +199,7 @@ int main_channel_client_push_ping(MainChannelClient *mcc, int size) return FALSE; } item = main_ping_item_new(size); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); return TRUE; } @@ -117,7 +217,7 @@ void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_ { PipeItem *item = main_agent_tokens_item_new(num_tokens); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } static PipeItem *main_agent_data_item_new(uint8_t* data, size_t len, @@ -140,7 +240,7 @@ void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, PipeItem *item; item = main_agent_data_item_new(data, len, free_data, opaque); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } static PipeItem *main_init_item_new(int connection_id, @@ -171,10 +271,10 @@ void main_channel_client_push_init(MainChannelClient *mcc, { PipeItem *item; - item = main_init_item_new(mcc->connection_id, display_channels_hint, + item = main_init_item_new(mcc->priv->connection_id, display_channels_hint, current_mouse_mode, is_client_mouse_allowed, multi_media_time, ram_hint); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } static PipeItem *main_name_item_new(const char *name) @@ -192,12 +292,12 @@ void main_channel_client_push_name(MainChannelClient *mcc, const char *name) { PipeItem *item; - if (!red_channel_client_test_remote_cap(&mcc->base, + if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc), SPICE_MAIN_CAP_NAME_AND_UUID)) return; item = main_name_item_new(name); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } static PipeItem *main_uuid_item_new(const uint8_t uuid[16]) @@ -214,39 +314,42 @@ void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16 { PipeItem *item; - if (!red_channel_client_test_remote_cap(&mcc->base, + if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc), SPICE_MAIN_CAP_NAME_AND_UUID)) return; item = main_uuid_item_new(uuid); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg) { PipeItem *item = main_notify_item_new((void *)msg, 1); - red_channel_client_pipe_add_push(&mcc->base, item); + red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item); } void main_channel_client_handle_migrate_connected(MainChannelClient *mcc, int success, int seamless) { - spice_printerr("client %p connected: %d seamless %d", mcc->base.client, success, seamless); - if (mcc->mig_wait_connect) { - MainChannel *main_channel = SPICE_CONTAINEROF(mcc->base.channel, MainChannel, base); + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); + RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc)); + spice_printerr("client %p connected: %d seamless %d", + client, success, seamless); + if (mcc->priv->mig_wait_connect) { + MainChannel *main_channel = SPICE_CONTAINEROF(channel, MainChannel, base); - mcc->mig_wait_connect = FALSE; - mcc->mig_connect_ok = success; + mcc->priv->mig_wait_connect = FALSE; + mcc->priv->mig_connect_ok = success; spice_assert(main_channel->num_clients_mig_wait); spice_assert(!seamless || main_channel->num_clients_mig_wait == 1); if (!--main_channel->num_clients_mig_wait) { - reds_on_main_migrate_connected(mcc->base.channel->reds, seamless && success); + reds_on_main_migrate_connected(channel->reds, seamless && success); } } else { if (success) { - spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client); - red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL); + spice_printerr("client %p MIGRATE_CANCEL", client); + red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc), SPICE_MSG_MAIN_MIGRATE_CANCEL); } } } @@ -254,12 +357,13 @@ void main_channel_client_handle_migrate_connected(MainChannelClient *mcc, void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc, uint32_t src_version) { - if (reds_on_migrate_dst_set_seamless(mcc->base.channel->reds, mcc, src_version)) { - mcc->seamless_mig_dst = TRUE; - red_channel_client_pipe_add_empty_msg(&mcc->base, + RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc)); + if (reds_on_migrate_dst_set_seamless(channel->reds, mcc, src_version)) { + mcc->priv->seamless_mig_dst = TRUE; + red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc), SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK); } else { - red_channel_client_pipe_add_empty_msg(&mcc->base, + red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc), SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK); } } @@ -273,47 +377,47 @@ void main_channel_client_handle_pong(MainChannelClient *mcc, SpiceMsgPing *ping, clock_gettime(CLOCK_MONOTONIC, &ts); roundtrip = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL - ping->timestamp; - if (ping->id == mcc->net_test_id) { - switch (mcc->net_test_stage) { + if (ping->id == mcc->priv->net_test_id) { + switch (mcc->priv->net_test_stage) { case NET_TEST_STAGE_WARMUP: - mcc->net_test_id++; - mcc->net_test_stage = NET_TEST_STAGE_LATENCY; + mcc->priv->net_test_id++; + mcc->priv->net_test_stage = NET_TEST_STAGE_LATENCY; break; case NET_TEST_STAGE_LATENCY: - mcc->net_test_id++; - mcc->net_test_stage = NET_TEST_STAGE_RATE; - mcc->latency = roundtrip; + mcc->priv->net_test_id++; + mcc->priv->net_test_stage = NET_TEST_STAGE_RATE; + mcc->priv->latency = roundtrip; break; case NET_TEST_STAGE_RATE: - mcc->net_test_id = 0; - if (roundtrip <= mcc->latency) { + mcc->priv->net_test_id = 0; + if (roundtrip <= mcc->priv->latency) { // probably high load on client or server result with incorrect values - mcc->latency = 0; - mcc->net_test_stage = NET_TEST_STAGE_INVALID; + mcc->priv->latency = 0; + mcc->priv->net_test_stage = NET_TEST_STAGE_INVALID; spice_printerr("net test: invalid values, latency %" PRIu64 " roundtrip %" PRIu64 ". assuming high" - "bandwidth", mcc->latency, roundtrip); - red_channel_client_start_connectivity_monitoring(&mcc->base, + "bandwidth", mcc->priv->latency, roundtrip); + red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc), CLIENT_CONNECTIVITY_TIMEOUT); break; } - mcc->bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000 - / (roundtrip - mcc->latency); - mcc->net_test_stage = NET_TEST_STAGE_COMPLETE; + mcc->priv->bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000 + / (roundtrip - mcc->priv->latency); + mcc->priv->net_test_stage = NET_TEST_STAGE_COMPLETE; spice_printerr("net test: latency %f ms, bitrate %"PRIu64" bps (%f Mbps)%s", - (double)mcc->latency / 1000, - mcc->bitrate_per_sec, - (double)mcc->bitrate_per_sec / 1024 / 1024, + (double)mcc->priv->latency / 1000, + mcc->priv->bitrate_per_sec, + (double)mcc->priv->bitrate_per_sec / 1024 / 1024, main_channel_client_is_low_bandwidth(mcc) ? " LOW BANDWIDTH" : ""); - red_channel_client_start_connectivity_monitoring(&mcc->base, + red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc), CLIENT_CONNECTIVITY_TIMEOUT); break; default: spice_printerr("invalid net test stage, ping id %d test id %d stage %d", ping->id, - mcc->net_test_id, - mcc->net_test_stage); - mcc->net_test_stage = NET_TEST_STAGE_INVALID; + mcc->priv->net_test_id, + mcc->priv->net_test_stage); + mcc->priv->net_test_stage = NET_TEST_STAGE_INVALID; } return; } else { @@ -323,101 +427,106 @@ void main_channel_client_handle_pong(MainChannelClient *mcc, SpiceMsgPing *ping, red_channel_client_handle_message(rcc, size, SPICE_MSGC_PONG, ping); } #ifdef RED_STATISTICS - reds_update_stat_value(rcc->channel->reds, roundtrip); + reds_update_stat_value(red_channel_client_get_channel(rcc)->reds, roundtrip); #endif } gboolean main_channel_client_get_seamless_migration(MainChannelClient *mcc) { - return mcc->seamless_mig_dst; + return mcc->priv->seamless_mig_dst; } void main_channel_client_handle_migrate_end(MainChannelClient *mcc) { - if (!red_client_during_migrate_at_target(mcc->base.client)) { + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); + if (!red_client_during_migrate_at_target(client)) { spice_printerr("unexpected SPICE_MSGC_MIGRATE_END"); return; } - if (!red_channel_client_test_remote_cap(&mcc->base, + if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc), SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) { spice_printerr("unexpected SPICE_MSGC_MIGRATE_END, " "client does not support semi-seamless migration"); return; } - red_client_semi_seamless_migrate_complete(mcc->base.client); + red_client_semi_seamless_migrate_complete(client); } void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc) { - if (mcc->mig_wait_connect) { - spice_printerr("client %p cancel wait connect", mcc->base.client); - mcc->mig_wait_connect = FALSE; - mcc->mig_connect_ok = FALSE; + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); + if (mcc->priv->mig_wait_connect) { + spice_printerr("client %p cancel wait connect", client); + mcc->priv->mig_wait_connect = FALSE; + mcc->priv->mig_connect_ok = FALSE; } - mcc->mig_wait_prev_complete = FALSE; + mcc->priv->mig_wait_prev_complete = FALSE; } void main_channel_client_migrate_dst_complete(MainChannelClient *mcc) { - if (mcc->mig_wait_prev_complete) { - if (mcc->mig_wait_prev_try_seamless) { - spice_assert(mcc->base.channel->clients_num == 1); - red_channel_client_pipe_add_type(&mcc->base, + RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc)); + if (mcc->priv->mig_wait_prev_complete) { + if (mcc->priv->mig_wait_prev_try_seamless) { + spice_assert(channel->clients_num == 1); + red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc), 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(RED_CHANNEL_CLIENT(mcc), PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN); } - mcc->mig_wait_connect = TRUE; - mcc->mig_wait_prev_complete = FALSE; + mcc->priv->mig_wait_connect = TRUE; + mcc->priv->mig_wait_prev_complete = FALSE; } } gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc, gboolean success) { + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); gboolean ret = FALSE; - int semi_seamless_support = red_channel_client_test_remote_cap(&mcc->base, + int semi_seamless_support = red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc), SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE); - if (semi_seamless_support && mcc->mig_connect_ok) { + if (semi_seamless_support && mcc->priv->mig_connect_ok) { if (success) { - spice_printerr("client %p MIGRATE_END", mcc->base.client); - red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_END); + spice_printerr("client %p MIGRATE_END", client); + red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc), SPICE_MSG_MAIN_MIGRATE_END); ret = TRUE; } else { - spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client); - red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL); + spice_printerr("client %p MIGRATE_CANCEL", client); + red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc), SPICE_MSG_MAIN_MIGRATE_CANCEL); } } 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); + spice_printerr("client %p SWITCH_HOST", client); + red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc), PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST); } } - mcc->mig_connect_ok = FALSE; - mcc->mig_wait_connect = FALSE; + mcc->priv->mig_connect_ok = FALSE; + mcc->priv->mig_wait_connect = FALSE; return ret; } uint32_t main_channel_client_get_link_id(MainChannelClient *mcc) { - return mcc->connection_id; + return mcc->priv->connection_id; } #ifdef RED_STATISTICS static void do_ping_client(MainChannelClient *mcc, const char *opt, int has_interval, int interval) { + RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc)); spice_printerr(""); if (!opt) { main_channel_client_push_ping(mcc, 0); } else if (!strcmp(opt, "on")) { if (has_interval && interval > 0) { - mcc->ping_interval = interval * 1000; + mcc->priv->ping_interval = interval * 1000; } - reds_core_timer_start(mcc->base.channel->reds, mcc->ping_timer, mcc->ping_interval); + reds_core_timer_start(channel->reds, mcc->priv->ping_timer, mcc->priv->ping_interval); } else if (!strcmp(opt, "off")) { - reds_core_timer_cancel(mcc->base.channel->reds, mcc->ping_timer); + reds_core_timer_cancel(channel->reds, mcc->priv->ping_timer); } else { return; } @@ -426,14 +535,15 @@ static void do_ping_client(MainChannelClient *mcc, static void ping_timer_cb(void *opaque) { MainChannelClient *mcc = opaque; + RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc)); - if (!red_channel_client_is_connected(&mcc->base)) { + if (!red_channel_client_is_connected(RED_CHANNEL_CLIENT(mcc))) { spice_printerr("not connected to peer, ping off"); - reds_core_timer_cancel(mcc->base.channel->reds, mcc->ping_timer); + reds_core_timer_cancel(channel->reds, mcc->priv->ping_timer); return; } do_ping_client(mcc, NULL, 0, 0); - reds_core_timer_start(mcc->base.channel->reds, mcc->ping_timer, mcc->ping_interval); + reds_core_timer_start(channel->reds, mcc->priv->ping_timer, mcc->priv->ping_interval); } #endif /* RED_STATISTICS */ @@ -442,66 +552,83 @@ MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient int num_common_caps, uint32_t *common_caps, int num_caps, uint32_t *caps) { - MainChannelClient *mcc = (MainChannelClient*) - red_channel_client_create(sizeof(MainChannelClient), &main_chan->base, - client, stream, FALSE, num_common_caps, - common_caps, num_caps, caps); - spice_assert(mcc != NULL); - mcc->connection_id = connection_id; - mcc->bitrate_per_sec = ~0; -#ifdef RED_STATISTICS - if (!(mcc->ping_timer = reds_core_timer_add(red_channel_get_server((RedChannel*)main_chan), ping_timer_cb, NULL))) { - spice_error("ping timer create failed"); + MainChannelClient *mcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); } - mcc->ping_interval = PING_INTERVAL; -#endif + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + + mcc = g_initable_new(TYPE_MAIN_CHANNEL_CLIENT, + NULL, NULL, + "channel", RED_CHANNEL(main_chan), + "client", client, + "stream", stream, + "monitor-latency", FALSE, + "caps", caps_array, + "common-caps", common_caps_array, + "connection-id", connection_id, + NULL); + + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); + return mcc; } int main_channel_client_is_network_info_initialized(MainChannelClient *mcc) { - return mcc->net_test_stage == NET_TEST_STAGE_COMPLETE; + return mcc->priv->net_test_stage == NET_TEST_STAGE_COMPLETE; } int main_channel_client_is_low_bandwidth(MainChannelClient *mcc) { // TODO: configurable? - return mcc->bitrate_per_sec < 10 * 1024 * 1024; + return mcc->priv->bitrate_per_sec < 10 * 1024 * 1024; } uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc) { - return mcc->bitrate_per_sec; + return mcc->priv->bitrate_per_sec; } uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc) { - return mcc->latency / 1000; + return mcc->priv->latency / 1000; } void main_channel_client_migrate(RedChannelClient *rcc) { - reds_on_main_channel_migrate(rcc->channel->reds, SPICE_CONTAINEROF(rcc, MainChannelClient, base)); + RedChannel *channel = red_channel_client_get_channel(rcc); + reds_on_main_channel_migrate(channel->reds, MAIN_CHANNEL_CLIENT(rcc)); red_channel_client_default_migrate(rcc); } gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc) { - RedChannelClient *rcc = main_channel_client_get_base(mcc); - MainChannel* main_channel = SPICE_CONTAINEROF(rcc->channel, MainChannel, base); + RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc); + MainChannel* main_channel = SPICE_CONTAINEROF(red_channel_client_get_channel(rcc), + MainChannel, base); if (red_channel_client_test_remote_cap(rcc, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) { RedClient *client = red_channel_client_get_client(rcc); if (red_client_during_migrate_at_target(client)) { spice_printerr("client %p: wait till previous migration completes", client); - mcc->mig_wait_prev_complete = TRUE; - mcc->mig_wait_prev_try_seamless = FALSE; + mcc->priv->mig_wait_prev_complete = TRUE; + mcc->priv->mig_wait_prev_try_seamless = FALSE; } else { red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN); - mcc->mig_wait_connect = TRUE; + mcc->priv->mig_wait_connect = TRUE; } - mcc->mig_connect_ok = FALSE; + mcc->priv->mig_connect_ok = FALSE; main_channel->num_clients_mig_wait++; return TRUE; } @@ -510,42 +637,44 @@ gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc) void main_channel_client_connect_seamless(MainChannelClient *mcc) { - spice_assert(red_channel_client_test_remote_cap(&mcc->base, + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); + spice_assert(red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc), SPICE_MAIN_CAP_SEAMLESS_MIGRATE)); - if (red_client_during_migrate_at_target(mcc->base.client)) { - spice_printerr("client %p: wait till previous migration completes", mcc->base.client); - mcc->mig_wait_prev_complete = TRUE; - mcc->mig_wait_prev_try_seamless = TRUE; + if (red_client_during_migrate_at_target(client)) { + spice_printerr("client %p: wait till previous migration completes", client); + mcc->priv->mig_wait_prev_complete = TRUE; + mcc->priv->mig_wait_prev_try_seamless = TRUE; } else { - red_channel_client_pipe_add_type(&mcc->base, + red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc), PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS); - mcc->mig_wait_connect = TRUE; + mcc->priv->mig_wait_connect = TRUE; } - mcc->mig_connect_ok = FALSE; + mcc->priv->mig_connect_ok = FALSE; } RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc) { spice_assert(mcc); - return &mcc->base; + return RED_CHANNEL_CLIENT(mcc); } uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc) { - return mcc->connection_id; + return mcc->priv->connection_id; } uint32_t main_channel_client_next_ping_id(MainChannelClient *mcc) { - return ++mcc->ping_id; + return ++mcc->priv->ping_id; } void main_channel_client_on_send_init(MainChannelClient *mcc) { - mcc->init_sent = TRUE; + mcc->priv->init_sent = TRUE; } gboolean main_channel_client_get_init_sent(MainChannelClient *mcc) { - return mcc->init_sent; + return mcc->priv->init_sent; } + diff --git a/server/main-channel-client.h b/server/main-channel-client.h index 06081b56..8643870b 100644 --- a/server/main-channel-client.h +++ b/server/main-channel-client.h @@ -17,15 +17,44 @@ #ifndef __MAIN_CHANNEL_CLIENT_H__ #define __MAIN_CHANNEL_CLIENT_H__ -#include "red-channel.h" +#include <glib-object.h> +#include "common/messages.h" +#include "red-channel-client.h" + +G_BEGIN_DECLS typedef struct MainChannel MainChannel; -typedef struct MainChannelClient MainChannelClient; + +#define TYPE_MAIN_CHANNEL_CLIENT main_channel_client_get_type() + +#define MAIN_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_MAIN_CHANNEL_CLIENT, MainChannelClient)) +#define MAIN_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_MAIN_CHANNEL_CLIENT, MainChannelClientClass)) +#define IS_MAIN_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_MAIN_CHANNEL_CLIENT)) +#define IS_MAIN_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_MAIN_CHANNEL_CLIENT)) +#define MAIN_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_MAIN_CHANNEL_CLIENT, MainChannelClientClass)) + +typedef struct _MainChannelClient MainChannelClient; +typedef struct _MainChannelClientClass MainChannelClientClass; +typedef struct _MainChannelClientPrivate MainChannelClientPrivate; + +struct _MainChannelClient +{ + RedChannelClient parent; + + MainChannelClientPrivate *priv; +}; + +struct _MainChannelClientClass +{ + RedChannelClientClass parent_class; +}; + +GType main_channel_client_get_type(void) G_GNUC_CONST; MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client, - RedsStream *stream, uint32_t connection_id, - int num_common_caps, uint32_t *common_caps, - int num_caps, uint32_t *caps); + RedsStream *stream, uint32_t connection_id, + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps); void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens); void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len, @@ -68,8 +97,6 @@ int main_channel_client_is_low_bandwidth(MainChannelClient *mcc); uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc); uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc); -RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc); - void main_channel_client_push_name(MainChannelClient *mcc, const char *name); void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]); diff --git a/server/main-channel.c b/server/main-channel.c index dfde29fc..8941f8bd 100644 --- a/server/main-channel.c +++ b/server/main-channel.c @@ -80,7 +80,7 @@ RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t c for (link = main_chan->base.clients; link != NULL; link = link->next) { rcc = link->data; - mcc = (MainChannelClient*) rcc; + mcc = MAIN_CHANNEL_CLIENT(rcc); if (main_channel_client_get_connection_id(mcc) == connection_id) { return red_channel_client_get_client(rcc); } @@ -116,7 +116,7 @@ PipeItem *main_multi_media_time_item_new(void *data, int num) static void main_channel_push_channels(MainChannelClient *mcc) { - RedChannelClient *rcc = main_channel_client_get_base(mcc); + RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc); if (red_client_during_migrate_at_target(red_channel_client_get_client(rcc))) { spice_printerr("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS" "during migration"); @@ -142,7 +142,7 @@ static void main_channel_marshall_ping(RedChannelClient *rcc, SpiceMarshaller *m, PingPipeItem *item) { - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); struct timespec time_space; SpiceMsgPing ping; int size_left = item->size; @@ -258,7 +258,7 @@ static int main_channel_handle_migrate_data(RedChannelClient *rcc, uint32_t size, void *message) { RedChannel *channel = red_channel_client_get_channel(rcc); - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); SpiceMigrateDataHeader *header = (SpiceMigrateDataHeader *)message; /* not supported with multi-clients */ @@ -440,7 +440,7 @@ static void main_channel_marshall_multi_media_time(RedChannelClient *rcc, static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base) { - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); SpiceMarshaller *m = red_channel_client_get_marshaller(rcc); /* In semi-seamless migration (dest side), the connection is started from scratch, and @@ -550,7 +550,7 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint { RedChannel *channel = red_channel_client_get_channel(rcc); MainChannel *main_chan = SPICE_CONTAINEROF(channel, MainChannel, base); - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); switch (type) { case SPICE_MSGC_MAIN_AGENT_START: { @@ -619,7 +619,7 @@ static uint8_t *main_channel_alloc_msg_rcv_buf(RedChannelClient *rcc, { RedChannel *channel = red_channel_client_get_channel(rcc); MainChannel *main_chan = SPICE_CONTAINEROF(channel, MainChannel, base); - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); if (type == SPICE_MSGC_MAIN_AGENT_DATA) { return reds_get_agent_data_buffer(channel->reds, mcc, size); @@ -737,7 +737,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel) for (link = main_channel->base.clients; link != NULL; link = link->next) { RedChannelClient *rcc = link->data; - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); if (main_channel_client_connect_semi_seamless(mcc)) main_channel->num_clients_mig_wait++; } @@ -752,7 +752,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel) for (link = main_channel->base.clients; link != NULL; link = link->next) { RedChannelClient *rcc = link->data; - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); main_channel_client_connect_seamless(mcc); main_channel->num_clients_mig_wait++; } @@ -792,7 +792,7 @@ void main_channel_migrate_cancel_wait(MainChannel *main_chan) for (link = main_chan->base.clients; link != NULL; link = link->next) { RedChannelClient *rcc = link->data; - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); main_channel_client_migrate_cancel_wait(mcc); } main_chan->num_clients_mig_wait = 0; @@ -812,7 +812,7 @@ int main_channel_migrate_src_complete(MainChannel *main_chan, int success) for (link = main_chan->base.clients; link != NULL; link = link->next) { RedChannelClient *rcc = link->data; - MainChannelClient *mcc = (MainChannelClient*)rcc; + MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc); if (main_channel_client_migrate_src_complete(mcc, success)) semi_seamless_count++; } diff --git a/server/red-channel-client-private.h b/server/red-channel-client-private.h index 04b6aff0..5e281191 100644 --- a/server/red-channel-client-private.h +++ b/server/red-channel-client-private.h @@ -21,12 +21,11 @@ #include "red-channel-client.h" #include "red-channel.h" -struct RedChannelClient { +struct _RedChannelClientPrivate { RedChannel *channel; RedClient *client; RedsStream *stream; - int dummy; - int dummy_connected; + gboolean monitor_latency; uint32_t refs; @@ -57,8 +56,6 @@ struct RedChannelClient { } urgent; } send_data; - OutgoingHandler outgoing; - IncomingHandler incoming; int during_send; int id; // debugging purposes Ring pipe; diff --git a/server/red-channel-client.c b/server/red-channel-client.c index fa101476..ac11e453 100644 --- a/server/red-channel-client.c +++ b/server/red-channel-client.c @@ -36,6 +36,28 @@ #include "red-channel-client-private.h" #include "red-channel.h" +static void red_channel_client_initable_interface_init(GInitableIface *iface); + +G_DEFINE_TYPE_WITH_CODE(RedChannelClient, red_channel_client, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, + red_channel_client_initable_interface_init)) + +#define CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), RED_TYPE_CHANNEL_CLIENT, RedChannelClientPrivate)) + +static gboolean red_channel_client_initable_init(GInitable *initable, + GCancellable *cancellable, + GError **error); + +enum { + PROP0, + PROP_STREAM, + PROP_CHANNEL, + PROP_CLIENT, + PROP_MONITOR_LATENCY, + PROP_COMMON_CAPS, + PROP_CAPS +}; + #define PING_TEST_TIMEOUT_MS 15000 #define PING_TEST_IDLE_NET_TIMEOUT_MS 100 @@ -58,29 +80,105 @@ typedef struct EmptyMsgPipeItem { int msg; } EmptyMsgPipeItem; +static uint32_t full_header_get_msg_size(SpiceDataHeaderOpaque *header) +{ + return GUINT32_FROM_LE(((SpiceDataHeader *)header->data)->size); +} + +static uint32_t mini_header_get_msg_size(SpiceDataHeaderOpaque *header) +{ + return GUINT32_FROM_LE(((SpiceMiniDataHeader *)header->data)->size); +} + +static uint16_t full_header_get_msg_type(SpiceDataHeaderOpaque *header) +{ + return GUINT16_FROM_LE(((SpiceDataHeader *)header->data)->type); +} + +static uint16_t mini_header_get_msg_type(SpiceDataHeaderOpaque *header) +{ + return GUINT16_FROM_LE(((SpiceMiniDataHeader *)header->data)->type); +} + +static void full_header_set_msg_type(SpiceDataHeaderOpaque *header, uint16_t type) +{ + ((SpiceDataHeader *)header->data)->type = GUINT16_TO_LE(type); +} + +static void mini_header_set_msg_type(SpiceDataHeaderOpaque *header, uint16_t type) +{ + ((SpiceMiniDataHeader *)header->data)->type = GUINT16_TO_LE(type); +} + +static void full_header_set_msg_size(SpiceDataHeaderOpaque *header, uint32_t size) +{ + ((SpiceDataHeader *)header->data)->size = GUINT32_TO_LE(size); +} + +static void mini_header_set_msg_size(SpiceDataHeaderOpaque *header, uint32_t size) +{ + ((SpiceMiniDataHeader *)header->data)->size = GUINT32_TO_LE(size); +} + +static void full_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t serial) +{ + ((SpiceDataHeader *)header->data)->serial = GUINT64_TO_LE(serial); +} + +static void mini_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t serial) +{ + spice_error("attempt to set header serial on mini header"); +} + +static void full_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list) +{ + ((SpiceDataHeader *)header->data)->sub_list = GUINT32_TO_LE(sub_list); +} + +static void mini_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list) +{ + spice_error("attempt to set header sub list on mini header"); +} + +static SpiceDataHeaderOpaque full_header_wrapper = {NULL, sizeof(SpiceDataHeader), + full_header_set_msg_type, + full_header_set_msg_size, + full_header_set_msg_serial, + full_header_set_msg_sub_list, + full_header_get_msg_type, + full_header_get_msg_size}; + +static SpiceDataHeaderOpaque mini_header_wrapper = {NULL, sizeof(SpiceMiniDataHeader), + mini_header_set_msg_type, + mini_header_set_msg_size, + mini_header_set_msg_serial, + mini_header_set_msg_sub_list, + mini_header_get_msg_type, + mini_header_get_msg_size}; + static void red_channel_client_start_ping_timer(RedChannelClient *rcc, uint32_t timeout) { - if (!rcc->latency_monitor.timer) { + if (!rcc->priv->latency_monitor.timer) { return; } - if (rcc->latency_monitor.state != PING_STATE_NONE) { + if (rcc->priv->latency_monitor.state != PING_STATE_NONE) { return; } - rcc->latency_monitor.state = PING_STATE_TIMER; - rcc->channel->core->timer_start(rcc->latency_monitor.timer, timeout); + rcc->priv->latency_monitor.state = PING_STATE_TIMER; + rcc->priv->channel->core->timer_start(rcc->priv->latency_monitor.timer, timeout); } static void red_channel_client_cancel_ping_timer(RedChannelClient *rcc) { - if (!rcc->latency_monitor.timer) { + if (!rcc->priv->latency_monitor.timer) { return; } - if (rcc->latency_monitor.state != PING_STATE_TIMER) { + if (rcc->priv->latency_monitor.state != PING_STATE_TIMER) { return; } - rcc->channel->core->timer_cancel(rcc->latency_monitor.timer); - rcc->latency_monitor.state = PING_STATE_NONE; + rcc->priv->channel->core->timer_cancel(rcc->priv->latency_monitor.timer); + rcc->priv->latency_monitor.state = PING_STATE_NONE; } static void red_channel_client_restart_ping_timer(RedChannelClient *rcc) @@ -91,7 +189,7 @@ static void red_channel_client_restart_ping_timer(RedChannelClient *rcc) clock_gettime(CLOCK_MONOTONIC, &ts); passed = ts.tv_sec * 1000000000LL + ts.tv_nsec; - passed = passed - rcc->latency_monitor.last_pong_time; + passed = passed - rcc->priv->latency_monitor.last_pong_time; passed /= 1000*1000; timeout = PING_TEST_IDLE_NET_TIMEOUT_MS; if (passed < PING_TEST_TIMEOUT_MS) { @@ -101,9 +199,233 @@ static void red_channel_client_restart_ping_timer(RedChannelClient *rcc) red_channel_client_start_ping_timer(rcc, timeout); } +static void +red_channel_client_get_property(GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + RedChannelClient *self = RED_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_STREAM: + g_value_set_pointer(value, self->priv->stream); + break; + case PROP_CHANNEL: + g_value_set_pointer(value, self->priv->channel); + break; + case PROP_CLIENT: + g_value_set_pointer(value, self->priv->client); + break; + case PROP_MONITOR_LATENCY: + g_value_set_boolean(value, self->priv->monitor_latency); + break; + case PROP_COMMON_CAPS: + { + GArray *arr = g_array_sized_new(FALSE, FALSE, + sizeof(*self->priv->remote_caps.common_caps), + self->priv->remote_caps.num_common_caps); + g_value_take_boxed(value, arr); + } + break; + case PROP_CAPS: + { + GArray *arr = g_array_sized_new(FALSE, FALSE, + sizeof(*self->priv->remote_caps.caps), + self->priv->remote_caps.num_caps); + g_value_take_boxed(value, arr); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void +red_channel_client_set_property(GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + RedChannelClient *self = RED_CHANNEL_CLIENT(object); + + switch (property_id) + { + case PROP_STREAM: + self->priv->stream = g_value_get_pointer(value); + break; + case PROP_CHANNEL: + if (self->priv->channel) + red_channel_unref(self->priv->channel); + self->priv->channel = g_value_get_pointer(value); + if (self->priv->channel) + red_channel_ref(self->priv->channel); + break; + case PROP_CLIENT: + self->priv->client = g_value_get_pointer(value); + break; + case PROP_MONITOR_LATENCY: + self->priv->monitor_latency = g_value_get_boolean(value); + break; + case PROP_COMMON_CAPS: + { + GArray *caps = g_value_get_boxed(value); + if (caps) { + self->priv->remote_caps.num_common_caps = caps->len; + self->priv->remote_caps.common_caps = spice_memdup(caps->data, caps->len * sizeof(uint32_t)); + } + } + break; + case PROP_CAPS: + { + GArray *caps = g_value_get_boxed(value); + if (caps) { + self->priv->remote_caps.num_caps = caps->len; + self->priv->remote_caps.caps = spice_memdup(caps->data, caps->len * sizeof(uint32_t)); + } + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void red_channel_client_destroy_remote_caps(RedChannelClient* rcc) +{ + rcc->priv->remote_caps.num_common_caps = 0; + free(rcc->priv->remote_caps.common_caps); + rcc->priv->remote_caps.num_caps = 0; + free(rcc->priv->remote_caps.caps); +} + +static void +red_channel_client_finalize(GObject *object) +{ + RedChannelClient *self = RED_CHANNEL_CLIENT(object); + + reds_stream_free(self->priv->stream); + self->priv->stream = NULL; + + if (self->priv->send_data.main.marshaller) + spice_marshaller_destroy(self->priv->send_data.main.marshaller); + + if (self->priv->send_data.urgent.marshaller) + spice_marshaller_destroy(self->priv->send_data.urgent.marshaller); + + red_channel_client_destroy_remote_caps(self); + if (self->priv->channel) + red_channel_unref(self->priv->channel); + + G_OBJECT_CLASS(red_channel_client_parent_class)->finalize(object); +} + +static void red_channel_client_initable_interface_init(GInitableIface *iface) +{ + iface->init = red_channel_client_initable_init; +} + +static gboolean red_channel_client_default_is_connected(RedChannelClient *rcc); +static void red_channel_client_default_disconnect(RedChannelClient *rcc); + + +static void red_channel_client_constructed(GObject *object) +{ + RedChannelClient *self = RED_CHANNEL_CLIENT(object); + + if (red_channel_client_test_remote_common_cap(self, SPICE_COMMON_CAP_MINI_HEADER)) { + self->incoming.header = mini_header_wrapper; + self->priv->send_data.header = mini_header_wrapper; + self->priv->is_mini_header = TRUE; + } else { + self->incoming.header = full_header_wrapper; + self->priv->send_data.header = full_header_wrapper; + self->priv->is_mini_header = FALSE; + } +} + +static void red_channel_client_class_init(RedChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_debug("%s", G_STRFUNC); + g_type_class_add_private(klass, sizeof(RedChannelClientPrivate)); + + object_class->get_property = red_channel_client_get_property; + object_class->set_property = red_channel_client_set_property; + object_class->finalize = red_channel_client_finalize; + object_class->constructed = red_channel_client_constructed; + + klass->is_connected = red_channel_client_default_is_connected; + klass->disconnect = red_channel_client_default_disconnect; + + g_object_class_install_property(object_class, + PROP_STREAM, + g_param_spec_pointer("stream", "stream", + "Associated RedStream", + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE + | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property(object_class, + PROP_CHANNEL, + g_param_spec_pointer("channel", "channel", + "Associated RedChannel", + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE + | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property(object_class, + PROP_CLIENT, + g_param_spec_pointer("client", "client", + "Associated RedClient", + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE + | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property(object_class, + PROP_MONITOR_LATENCY, + g_param_spec_boolean("monitor-latency", "monitor-latency", + "Whether to monitor latency for this client", + FALSE, + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property(object_class, + PROP_COMMON_CAPS, + g_param_spec_boxed("common-caps", "common-caps", + "Common Capabilities", + G_TYPE_ARRAY, + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property(object_class, + PROP_CAPS, + g_param_spec_boxed("caps", "caps", + "Capabilities", + G_TYPE_ARRAY, + G_PARAM_STATIC_STRINGS + | G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); +} + +static void +red_channel_client_init(RedChannelClient *self) +{ + self->priv = CHANNEL_CLIENT_PRIVATE(self); + self->priv->ack_data.messages_window = ~0; // blocks send message (maybe use send_data.blocked + + // block flags) + self->priv->ack_data.client_generation = ~0; + self->priv->ack_data.client_window = CLIENT_ACK_WINDOW; + self->priv->send_data.main.marshaller = spice_marshaller_new(); + self->priv->send_data.urgent.marshaller = spice_marshaller_new(); + + self->priv->send_data.marshaller = self->priv->send_data.main.marshaller; + + ring_init(&self->priv->pipe); + self->priv->pipe_size = 0; +} + RedChannel* red_channel_client_get_channel(RedChannelClient* rcc) { - return rcc->channel; + return rcc->priv->channel; } IncomingHandler* red_channel_client_get_incoming_handler(RedChannelClient *rcc) @@ -115,18 +437,18 @@ void red_channel_client_on_output(void *opaque, int n) { RedChannelClient *rcc = opaque; - if (rcc->connectivity_monitor.timer) { - rcc->connectivity_monitor.out_bytes += n; + if (rcc->priv->connectivity_monitor.timer) { + rcc->priv->connectivity_monitor.out_bytes += n; } - reds_stat_inc_counter(reds, rcc->channel->out_bytes_counter, n); + reds_stat_inc_counter(reds, rcc->priv->channel->out_bytes_counter, n); } void red_channel_client_on_input(void *opaque, int n) { RedChannelClient *rcc = opaque; - if (rcc->connectivity_monitor.timer) { - rcc->connectivity_monitor.in_bytes += n; + if (rcc->priv->connectivity_monitor.timer) { + rcc->priv->connectivity_monitor.in_bytes += n; } } @@ -134,7 +456,7 @@ int red_channel_client_get_out_msg_size(void *opaque) { RedChannelClient *rcc = (RedChannelClient *)opaque; - return rcc->send_data.size; + return rcc->priv->send_data.size; } void red_channel_client_prepare_out_msg(void *opaque, struct iovec *vec, @@ -142,7 +464,7 @@ void red_channel_client_prepare_out_msg(void *opaque, struct iovec *vec, { RedChannelClient *rcc = (RedChannelClient *)opaque; - *vec_size = spice_marshaller_fill_iovec(rcc->send_data.marshaller, + *vec_size = spice_marshaller_fill_iovec(rcc->priv->send_data.marshaller, vec, IOV_MAX, pos); } @@ -150,46 +472,46 @@ void red_channel_client_on_out_block(void *opaque) { RedChannelClient *rcc = (RedChannelClient *)opaque; - rcc->send_data.blocked = TRUE; - rcc->channel->core->watch_update_mask(rcc->stream->watch, - SPICE_WATCH_EVENT_READ | - SPICE_WATCH_EVENT_WRITE); + rcc->priv->send_data.blocked = TRUE; + rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch, + SPICE_WATCH_EVENT_READ | + SPICE_WATCH_EVENT_WRITE); } static inline int red_channel_client_urgent_marshaller_is_active(RedChannelClient *rcc) { - return (rcc->send_data.marshaller == rcc->send_data.urgent.marshaller); + return (rcc->priv->send_data.marshaller == rcc->priv->send_data.urgent.marshaller); } static void red_channel_client_reset_send_data(RedChannelClient *rcc) { - spice_marshaller_reset(rcc->send_data.marshaller); - rcc->send_data.header.data = spice_marshaller_reserve_space(rcc->send_data.marshaller, - rcc->send_data.header.header_size); - spice_marshaller_set_base(rcc->send_data.marshaller, rcc->send_data.header.header_size); - rcc->send_data.header.set_msg_type(&rcc->send_data.header, 0); - rcc->send_data.header.set_msg_size(&rcc->send_data.header, 0); + spice_marshaller_reset(rcc->priv->send_data.marshaller); + rcc->priv->send_data.header.data = spice_marshaller_reserve_space(rcc->priv->send_data.marshaller, + rcc->priv->send_data.header.header_size); + spice_marshaller_set_base(rcc->priv->send_data.marshaller, rcc->priv->send_data.header.header_size); + rcc->priv->send_data.header.set_msg_type(&rcc->priv->send_data.header, 0); + rcc->priv->send_data.header.set_msg_size(&rcc->priv->send_data.header, 0); /* Keeping the serial consecutive: reseting it if reset_send_data * has been called before, but no message has been sent since then. */ - if (rcc->send_data.last_sent_serial != rcc->send_data.serial) { - spice_assert(rcc->send_data.serial - rcc->send_data.last_sent_serial == 1); + if (rcc->priv->send_data.last_sent_serial != rcc->priv->send_data.serial) { + spice_assert(rcc->priv->send_data.serial - rcc->priv->send_data.last_sent_serial == 1); /* When the urgent marshaller is active, the serial was incremented by * the call to reset_send_data that was made for the main marshaller. * The urgent msg receives this serial, and the main msg serial is - * the following one. Thus, (rcc->send_data.serial - rcc->send_data.last_sent_serial) + * the following one. Thus, (rcc->priv->send_data.serial - rcc->priv->send_data.last_sent_serial) * should be 1 in this case*/ if (!red_channel_client_urgent_marshaller_is_active(rcc)) { - rcc->send_data.serial = rcc->send_data.last_sent_serial; + rcc->priv->send_data.serial = rcc->priv->send_data.last_sent_serial; } } - rcc->send_data.serial++; + rcc->priv->send_data.serial++; - if (!rcc->is_mini_header) { - spice_assert(rcc->send_data.marshaller != rcc->send_data.urgent.marshaller); - rcc->send_data.header.set_msg_sub_list(&rcc->send_data.header, 0); - rcc->send_data.header.set_msg_serial(&rcc->send_data.header, rcc->send_data.serial); + if (!rcc->priv->is_mini_header) { + spice_assert(rcc->priv->send_data.marshaller != rcc->priv->send_data.urgent.marshaller); + rcc->priv->send_data.header.set_msg_sub_list(&rcc->priv->send_data.header, 0); + rcc->priv->send_data.header.set_msg_serial(&rcc->priv->send_data.header, rcc->priv->send_data.serial); } } @@ -199,11 +521,11 @@ static void red_channel_client_send_set_ack(RedChannelClient *rcc) spice_assert(rcc); red_channel_client_init_send_data(rcc, SPICE_MSG_SET_ACK, NULL); - ack.generation = ++rcc->ack_data.generation; - ack.window = rcc->ack_data.client_window; - rcc->ack_data.messages_window = 0; + ack.generation = ++rcc->priv->ack_data.generation; + ack.window = rcc->priv->ack_data.client_window; + rcc->priv->ack_data.messages_window = 0; - spice_marshall_msg_set_ack(rcc->send_data.marshaller, &ack); + spice_marshall_msg_set_ack(rcc->priv->send_data.marshaller, &ack); red_channel_client_begin_send_message(rcc); } @@ -213,10 +535,10 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc) SpiceMsgMigrate migrate; red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE, NULL); - migrate.flags = rcc->channel->migration_flags; - spice_marshall_msg_migrate(rcc->send_data.marshaller, &migrate); - if (rcc->channel->migration_flags & SPICE_MIGRATE_NEED_FLUSH) { - rcc->wait_migrate_flush_mark = TRUE; + migrate.flags = rcc->priv->channel->migration_flags; + spice_marshall_msg_migrate(rcc->priv->send_data.marshaller, &migrate); + if (rcc->priv->channel->migration_flags & SPICE_MIGRATE_NEED_FLUSH) { + rcc->priv->wait_migrate_flush_mark = TRUE; } red_channel_client_begin_send_message(rcc); @@ -227,25 +549,25 @@ static void red_channel_client_send_ping(RedChannelClient *rcc) SpiceMsgPing ping; struct timespec ts; - if (!rcc->latency_monitor.warmup_was_sent) { // latency test start + if (!rcc->priv->latency_monitor.warmup_was_sent) { // latency test start int delay_val; socklen_t opt_size = sizeof(delay_val); - rcc->latency_monitor.warmup_was_sent = TRUE; + rcc->priv->latency_monitor.warmup_was_sent = TRUE; /* * When testing latency, TCP_NODELAY must be switched on, otherwise, * sending the ping message is delayed by Nagle algorithm, and the * roundtrip measurment is less accurate (bigger). */ - rcc->latency_monitor.tcp_nodelay = 1; - if (getsockopt(rcc->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, + rcc->priv->latency_monitor.tcp_nodelay = 1; + if (getsockopt(rcc->priv->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, &opt_size) == -1) { spice_warning("getsockopt failed, %s", strerror(errno)); } else { - rcc->latency_monitor.tcp_nodelay = delay_val; + rcc->priv->latency_monitor.tcp_nodelay = delay_val; if (!delay_val) { delay_val = 1; - if (setsockopt(rcc->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, + if (setsockopt(rcc->priv->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) { if (errno != ENOTSUP) { spice_warning("setsockopt failed, %s", strerror(errno)); @@ -256,10 +578,10 @@ static void red_channel_client_send_ping(RedChannelClient *rcc) } red_channel_client_init_send_data(rcc, SPICE_MSG_PING, NULL); - ping.id = rcc->latency_monitor.id; + ping.id = rcc->priv->latency_monitor.id; clock_gettime(CLOCK_MONOTONIC, &ts); ping.timestamp = ts.tv_sec * 1000000000LL + ts.tv_nsec; - spice_marshall_msg_ping(rcc->send_data.marshaller, &ping); + spice_marshall_msg_ping(rcc->priv->send_data.marshaller, &ping); red_channel_client_begin_send_message(rcc); } @@ -298,7 +620,7 @@ static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item) handled = FALSE; } if (!handled) { - rcc->channel->channel_cbs.send_item(rcc, item); + rcc->priv->channel->channel_cbs.send_item(rcc, item); } } @@ -312,48 +634,50 @@ static void red_channel_client_release_item(RedChannelClient *rcc, PipeItem *ite free(item); break; default: - rcc->channel->channel_cbs.release_item(rcc, item, item_pushed); + rcc->priv->channel->channel_cbs.release_item(rcc, item, item_pushed); } } static inline void red_channel_client_release_sent_item(RedChannelClient *rcc) { - if (rcc->send_data.item) { + if (rcc->priv->send_data.item) { red_channel_client_release_item(rcc, - rcc->send_data.item, TRUE); - rcc->send_data.item = NULL; + rcc->priv->send_data.item, TRUE); + rcc->priv->send_data.item = NULL; } } static void red_channel_client_restore_main_sender(RedChannelClient *rcc) { - spice_marshaller_reset(rcc->send_data.urgent.marshaller); - rcc->send_data.marshaller = rcc->send_data.main.marshaller; - rcc->send_data.header.data = rcc->send_data.main.header_data; - if (!rcc->is_mini_header) { - rcc->send_data.header.set_msg_serial(&rcc->send_data.header, rcc->send_data.serial); + spice_marshaller_reset(rcc->priv->send_data.urgent.marshaller); + rcc->priv->send_data.marshaller = rcc->priv->send_data.main.marshaller; + rcc->priv->send_data.header.data = rcc->priv->send_data.main.header_data; + if (!rcc->priv->is_mini_header) { + rcc->priv->send_data.header.set_msg_serial(&rcc->priv->send_data.header, rcc->priv->send_data.serial); } - rcc->send_data.item = rcc->send_data.main.item; + rcc->priv->send_data.item = rcc->priv->send_data.main.item; } void red_channel_client_on_out_msg_done(void *opaque) { RedChannelClient *rcc = (RedChannelClient *)opaque; - rcc->send_data.size = 0; + rcc->priv->send_data.size = 0; red_channel_client_release_sent_item(rcc); - if (rcc->send_data.blocked) { - rcc->send_data.blocked = FALSE; - rcc->channel->core->watch_update_mask(rcc->stream->watch, - SPICE_WATCH_EVENT_READ); + if (rcc->priv->send_data.blocked) { + rcc->priv->send_data.blocked = FALSE; + rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch, + SPICE_WATCH_EVENT_READ); } if (red_channel_client_urgent_marshaller_is_active(rcc)) { red_channel_client_restore_main_sender(rcc); - spice_assert(rcc->send_data.header.data != NULL); + spice_assert(rcc->priv->send_data.header.data != NULL); red_channel_client_begin_send_message(rcc); } else { - if (rcc->latency_monitor.timer && !rcc->send_data.blocked && rcc->pipe_size == 0) { + if (rcc->priv->latency_monitor.timer + && !rcc->priv->send_data.blocked + && rcc->priv->pipe_size == 0) { /* It is possible that the socket will become idle, so we may be able to test latency */ red_channel_client_restart_ping_timer(rcc); } @@ -363,49 +687,30 @@ void red_channel_client_on_out_msg_done(void *opaque) static void red_channel_client_pipe_remove(RedChannelClient *rcc, PipeItem *item) { - rcc->pipe_size--; + rcc->priv->pipe_size--; ring_remove(&item->link); } -static void red_channel_client_set_remote_caps(RedChannelClient* rcc, - int num_common_caps, uint32_t *common_caps, - int num_caps, uint32_t *caps) -{ - rcc->remote_caps.num_common_caps = num_common_caps; - rcc->remote_caps.common_caps = spice_memdup(common_caps, num_common_caps * sizeof(uint32_t)); - - rcc->remote_caps.num_caps = num_caps; - rcc->remote_caps.caps = spice_memdup(caps, num_caps * sizeof(uint32_t)); -} - -static void red_channel_client_destroy_remote_caps(RedChannelClient* rcc) -{ - rcc->remote_caps.num_common_caps = 0; - free(rcc->remote_caps.common_caps); - rcc->remote_caps.num_caps = 0; - free(rcc->remote_caps.caps); -} - int red_channel_client_test_remote_common_cap(RedChannelClient *rcc, uint32_t cap) { - return test_capability(rcc->remote_caps.common_caps, - rcc->remote_caps.num_common_caps, + return test_capability(rcc->priv->remote_caps.common_caps, + rcc->priv->remote_caps.num_common_caps, cap); } int red_channel_client_test_remote_cap(RedChannelClient *rcc, uint32_t cap) { - return test_capability(rcc->remote_caps.caps, - rcc->remote_caps.num_caps, + return test_capability(rcc->priv->remote_caps.caps, + rcc->priv->remote_caps.num_caps, cap); } static void red_channel_client_push_ping(RedChannelClient *rcc) { - spice_assert(rcc->latency_monitor.state == PING_STATE_NONE); - rcc->latency_monitor.state = PING_STATE_WARMUP; - rcc->latency_monitor.warmup_was_sent = FALSE; - rcc->latency_monitor.id = rand(); + spice_assert(rcc->priv->latency_monitor.state == PING_STATE_NONE); + rcc->priv->latency_monitor.state = PING_STATE_WARMUP; + rcc->priv->latency_monitor.warmup_was_sent = FALSE; + rcc->priv->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); } @@ -414,7 +719,7 @@ static void red_channel_client_ping_timer(void *opaque) { RedChannelClient *rcc = opaque; - spice_assert(rcc->latency_monitor.state == PING_STATE_TIMER); + spice_assert(rcc->priv->latency_monitor.state == PING_STATE_TIMER); red_channel_client_cancel_ping_timer(rcc); #ifdef HAVE_LINUX_SOCKIOS_H /* SIOCOUTQ is a Linux only ioctl on sockets. */ @@ -422,7 +727,7 @@ static void red_channel_client_ping_timer(void *opaque) int so_unsent_size = 0; /* retrieving the occupied size of the socket's tcp snd buffer (unacked + unsent) */ - if (ioctl(rcc->stream->socket, SIOCOUTQ, &so_unsent_size) == -1) { + if (ioctl(rcc->priv->stream->socket, SIOCOUTQ, &so_unsent_size) == -1) { spice_printerr("ioctl(SIOCOUTQ) failed, %s", strerror(errno)); } if (so_unsent_size > 0) { @@ -440,8 +745,8 @@ static void red_channel_client_ping_timer(void *opaque) static inline int red_channel_client_waiting_for_ack(RedChannelClient *rcc) { - return (rcc->channel->handle_acks && - (rcc->ack_data.messages_window > rcc->ack_data.client_window * 2)); + return (rcc->priv->channel->handle_acks && + (rcc->priv->ack_data.messages_window > rcc->priv->ack_data.client_window * 2)); } /* @@ -459,12 +764,12 @@ static inline int red_channel_client_waiting_for_ack(RedChannelClient *rcc) static void red_channel_client_connectivity_timer(void *opaque) { RedChannelClient *rcc = opaque; - RedChannelClientConnectivityMonitor *monitor = &rcc->connectivity_monitor; + RedChannelClientConnectivityMonitor *monitor = &rcc->priv->connectivity_monitor; int is_alive = TRUE; if (monitor->state == CONNECTIVITY_STATE_BLOCKED) { if (monitor->in_bytes == 0 && monitor->out_bytes == 0) { - if (!rcc->send_data.blocked && !red_channel_client_waiting_for_ack(rcc)) { + if (!rcc->priv->send_data.blocked && !red_channel_client_waiting_for_ack(rcc)) { spice_error("mismatch between rcc-state and connectivity-state"); } spice_debug("rcc is blocked; connection is idle"); @@ -472,8 +777,8 @@ static void red_channel_client_connectivity_timer(void *opaque) } } else if (monitor->state == CONNECTIVITY_STATE_WAIT_PONG) { if (monitor->in_bytes == 0) { - if (rcc->latency_monitor.state != PING_STATE_WARMUP && - rcc->latency_monitor.state != PING_STATE_LATENCY) { + if (rcc->priv->latency_monitor.state != PING_STATE_WARMUP && + rcc->priv->latency_monitor.state != PING_STATE_LATENCY) { spice_error("mismatch between rcc-state and connectivity-state"); } spice_debug("rcc waits for pong; connection is idle"); @@ -484,20 +789,20 @@ static void red_channel_client_connectivity_timer(void *opaque) if (is_alive) { monitor->in_bytes = 0; monitor->out_bytes = 0; - if (rcc->send_data.blocked || red_channel_client_waiting_for_ack(rcc)) { + if (rcc->priv->send_data.blocked || red_channel_client_waiting_for_ack(rcc)) { monitor->state = CONNECTIVITY_STATE_BLOCKED; - } else if (rcc->latency_monitor.state == PING_STATE_WARMUP || - rcc->latency_monitor.state == PING_STATE_LATENCY) { + } else if (rcc->priv->latency_monitor.state == PING_STATE_WARMUP || + rcc->priv->latency_monitor.state == PING_STATE_LATENCY) { monitor->state = CONNECTIVITY_STATE_WAIT_PONG; } else { monitor->state = CONNECTIVITY_STATE_CONNECTED; } - rcc->channel->core->timer_start(rcc->connectivity_monitor.timer, - rcc->connectivity_monitor.timeout); + rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer, + rcc->priv->connectivity_monitor.timeout); } else { monitor->state = CONNECTIVITY_STATE_DISCONNECTED; spice_warning("rcc %p on channel %d:%d has been unresponsive for more than %u ms, disconnecting", - rcc, rcc->channel->type, rcc->channel->id, monitor->timeout); + rcc, rcc->priv->channel->type, rcc->priv->channel->id, monitor->timeout); red_channel_client_disconnect(rcc); } } @@ -515,22 +820,22 @@ void red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uin * channel-client even if there are no ongoing channel specific messages * on this channel. */ - if (rcc->latency_monitor.timer == NULL) { - rcc->latency_monitor.timer = rcc->channel->core->timer_add( + if (rcc->priv->latency_monitor.timer == NULL) { + rcc->priv->latency_monitor.timer = rcc->priv->channel->core->timer_add( red_channel_client_ping_timer, rcc); - if (!red_client_during_migrate_at_target(rcc->client)) { + if (!red_client_during_migrate_at_target(rcc->priv->client)) { red_channel_client_start_ping_timer(rcc, PING_TEST_IDLE_NET_TIMEOUT_MS); } - rcc->latency_monitor.roundtrip = -1; + rcc->priv->latency_monitor.roundtrip = -1; } - if (rcc->connectivity_monitor.timer == NULL) { - rcc->connectivity_monitor.state = CONNECTIVITY_STATE_CONNECTED; - rcc->connectivity_monitor.timer = rcc->channel->core->timer_add( + if (rcc->priv->connectivity_monitor.timer == NULL) { + rcc->priv->connectivity_monitor.state = CONNECTIVITY_STATE_CONNECTED; + rcc->priv->connectivity_monitor.timer = rcc->priv->channel->core->timer_add( red_channel_client_connectivity_timer, rcc); - rcc->connectivity_monitor.timeout = timeout_ms; - if (!red_client_during_migrate_at_target(rcc->client)) { - rcc->channel->core->timer_start(rcc->connectivity_monitor.timer, - rcc->connectivity_monitor.timeout); + rcc->priv->connectivity_monitor.timeout = timeout_ms; + if (!red_client_during_migrate_at_target(rcc->priv->client)) { + rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer, + rcc->priv->connectivity_monitor.timeout); } } } @@ -539,92 +844,16 @@ static void red_channel_client_event(int fd, int event, void *data) { RedChannelClient *rcc = (RedChannelClient *)data; - red_channel_client_ref(rcc); + g_object_ref(rcc); if (event & SPICE_WATCH_EVENT_READ) { red_channel_client_receive(rcc); } if (event & SPICE_WATCH_EVENT_WRITE) { red_channel_client_push(rcc); } - red_channel_client_unref(rcc); -} - -static uint32_t full_header_get_msg_size(SpiceDataHeaderOpaque *header) -{ - return GUINT32_FROM_LE(((SpiceDataHeader *)header->data)->size); -} - -static uint32_t mini_header_get_msg_size(SpiceDataHeaderOpaque *header) -{ - return GUINT32_FROM_LE(((SpiceMiniDataHeader *)header->data)->size); -} - -static uint16_t full_header_get_msg_type(SpiceDataHeaderOpaque *header) -{ - return GUINT16_FROM_LE(((SpiceDataHeader *)header->data)->type); -} - -static uint16_t mini_header_get_msg_type(SpiceDataHeaderOpaque *header) -{ - return GUINT16_FROM_LE(((SpiceMiniDataHeader *)header->data)->type); -} - -static void full_header_set_msg_type(SpiceDataHeaderOpaque *header, uint16_t type) -{ - ((SpiceDataHeader *)header->data)->type = GUINT16_TO_LE(type); -} - -static void mini_header_set_msg_type(SpiceDataHeaderOpaque *header, uint16_t type) -{ - ((SpiceMiniDataHeader *)header->data)->type = GUINT16_TO_LE(type); -} - -static void full_header_set_msg_size(SpiceDataHeaderOpaque *header, uint32_t size) -{ - ((SpiceDataHeader *)header->data)->size = GUINT32_TO_LE(size); -} - -static void mini_header_set_msg_size(SpiceDataHeaderOpaque *header, uint32_t size) -{ - ((SpiceMiniDataHeader *)header->data)->size = GUINT32_TO_LE(size); -} - -static void full_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t serial) -{ - ((SpiceDataHeader *)header->data)->serial = GUINT64_TO_LE(serial); -} - -static void mini_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t serial) -{ - spice_error("attempt to set header serial on mini header"); + g_object_unref(rcc); } -static void full_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list) -{ - ((SpiceDataHeader *)header->data)->sub_list = GUINT32_TO_LE(sub_list); -} - -static void mini_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list) -{ - spice_error("attempt to set header sub list on mini header"); -} - -static SpiceDataHeaderOpaque full_header_wrapper = {NULL, sizeof(SpiceDataHeader), - full_header_set_msg_type, - full_header_set_msg_size, - full_header_set_msg_serial, - full_header_set_msg_sub_list, - full_header_get_msg_type, - full_header_get_msg_size}; - -static SpiceDataHeaderOpaque mini_header_wrapper = {NULL, sizeof(SpiceMiniDataHeader), - mini_header_set_msg_type, - mini_header_set_msg_size, - mini_header_set_msg_serial, - mini_header_set_msg_sub_list, - mini_header_get_msg_type, - mini_header_get_msg_size}; - static int red_channel_client_pre_create_validate(RedChannel *channel, RedClient *client) { if (red_client_get_channel(client, channel->type, channel->id)) { @@ -635,217 +864,163 @@ static int red_channel_client_pre_create_validate(RedChannel *channel, RedClient return TRUE; } -RedChannelClient *red_channel_client_create(int size, RedChannel *channel, RedClient *client, - RedsStream *stream, - int monitor_latency, - int num_common_caps, uint32_t *common_caps, - int num_caps, uint32_t *caps) -{ - RedChannelClient *rcc = NULL; - - pthread_mutex_lock(&client->lock); - if (!red_channel_client_pre_create_validate(channel, client)) { - goto error; - } - spice_assert(stream && channel && size >= sizeof(RedChannelClient)); - rcc = spice_malloc0(size); - rcc->stream = stream; - rcc->channel = channel; - rcc->client = client; - rcc->refs = 1; - rcc->ack_data.messages_window = ~0; // blocks send message (maybe use send_data.blocked + - // block flags) - rcc->ack_data.client_generation = ~0; - rcc->ack_data.client_window = CLIENT_ACK_WINDOW; - rcc->send_data.main.marshaller = spice_marshaller_new(); - rcc->send_data.urgent.marshaller = spice_marshaller_new(); - - rcc->send_data.marshaller = rcc->send_data.main.marshaller; - - rcc->incoming.opaque = rcc; - rcc->incoming.cb = &channel->incoming_cb; - - rcc->outgoing.opaque = rcc; - rcc->outgoing.cb = &channel->outgoing_cb; - rcc->outgoing.pos = 0; - rcc->outgoing.size = 0; - - red_channel_client_set_remote_caps(rcc, num_common_caps, common_caps, num_caps, caps); - if (red_channel_client_test_remote_common_cap(rcc, SPICE_COMMON_CAP_MINI_HEADER)) { - rcc->incoming.header = mini_header_wrapper; - rcc->send_data.header = mini_header_wrapper; - rcc->is_mini_header = TRUE; - } else { - rcc->incoming.header = full_header_wrapper; - rcc->send_data.header = full_header_wrapper; - rcc->is_mini_header = FALSE; +static gboolean red_channel_client_initable_init(GInitable *initable, + GCancellable *cancellable, + GError **error) +{ + GError *local_error = NULL; + RedChannelClient *self = RED_CHANNEL_CLIENT(initable); + pthread_mutex_lock(&self->priv->client->lock); + if (!red_channel_client_pre_create_validate(self->priv->channel, self->priv->client)) { + g_set_error(&local_error, + SPICE_SERVER_ERROR, + SPICE_SERVER_ERROR_FAILED, + "Client %p: duplicate channel type %d id %d", + self->priv->client, self->priv->channel->type, + self->priv->channel->id); + goto cleanup; + } + + if (self->priv->monitor_latency + && reds_stream_get_family(self->priv->stream) != AF_UNIX) { + self->priv->latency_monitor.timer = + self->priv->channel->core->timer_add(red_channel_client_ping_timer, + self); + + if (!self->priv->client->during_target_migrate) { + red_channel_client_start_ping_timer(self, + PING_TEST_IDLE_NET_TIMEOUT_MS); + } + self->priv->latency_monitor.roundtrip = -1; } - rcc->incoming.header.data = rcc->incoming.header_buf; - rcc->incoming.serial = 1; + self->incoming.opaque = self; + self->incoming.cb = &self->priv->channel->incoming_cb; + self->incoming.header.data = self->incoming.header_buf; + self->incoming.serial = 1; - if (!channel->channel_cbs.config_socket(rcc)) { - goto error; - } + self->outgoing.opaque = self; + self->outgoing.cb = &self->priv->channel->outgoing_cb; + self->outgoing.pos = 0; + self->outgoing.size = 0; - ring_init(&rcc->pipe); - rcc->pipe_size = 0; + if (self->priv->stream) + self->priv->stream->watch = + self->priv->channel->core->watch_add(self->priv->stream->socket, + SPICE_WATCH_EVENT_READ, + red_channel_client_event, + self); + self->priv->id = self->priv->channel->clients_num; + red_channel_add_client(self->priv->channel, self); + red_client_add_channel(self->priv->client, self); - stream->watch = channel->core->watch_add(stream->socket, - SPICE_WATCH_EVENT_READ, - red_channel_client_event, rcc); - rcc->id = g_list_length(channel->clients); - red_channel_add_client(channel, rcc); - red_client_add_channel(client, rcc); - red_channel_ref(channel); - pthread_mutex_unlock(&client->lock); + if (!self->priv->channel->channel_cbs.config_socket(self)) { + g_set_error_literal(&local_error, + SPICE_SERVER_ERROR, + SPICE_SERVER_ERROR_FAILED, + "Unable to configure socket"); + } - if (monitor_latency && reds_stream_get_family(stream) != AF_UNIX) { - rcc->latency_monitor.timer = channel->core->timer_add( - red_channel_client_ping_timer, rcc); - if (!client->during_target_migrate) { - red_channel_client_start_ping_timer(rcc, PING_TEST_IDLE_NET_TIMEOUT_MS); - } - rcc->latency_monitor.roundtrip = -1; +cleanup: + pthread_mutex_unlock(&self->priv->client->lock); + if (local_error) { + g_warning("Failed to create channel client: %s", local_error->message); + g_propagate_error(error, local_error); } + return local_error == NULL; +} - return rcc; -error: - free(rcc); - reds_stream_free(stream); - pthread_mutex_unlock(&client->lock); - return NULL; -} - -RedChannelClient *red_channel_client_create_dummy(int size, - RedChannel *channel, - RedClient *client, - int num_common_caps, uint32_t *common_caps, - int num_caps, uint32_t *caps) -{ - RedChannelClient *rcc = NULL; - - spice_assert(size >= sizeof(RedChannelClient)); - - pthread_mutex_lock(&client->lock); - if (!red_channel_client_pre_create_validate(channel, client)) { - goto error; - } - rcc = spice_malloc0(size); - rcc->refs = 1; - rcc->client = client; - rcc->channel = channel; - red_channel_ref(channel); - red_channel_client_set_remote_caps(rcc, num_common_caps, common_caps, num_caps, caps); - if (red_channel_client_test_remote_common_cap(rcc, SPICE_COMMON_CAP_MINI_HEADER)) { - rcc->incoming.header = mini_header_wrapper; - rcc->send_data.header = mini_header_wrapper; - rcc->is_mini_header = TRUE; - } else { - rcc->incoming.header = full_header_wrapper; - rcc->send_data.header = full_header_wrapper; - rcc->is_mini_header = FALSE; +RedChannelClient *red_channel_client_create(RedChannel *channel, RedClient *client, + RedsStream *stream, + int monitor_latency, + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps) +{ + RedChannelClient *rcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + rcc = g_initable_new(RED_TYPE_CHANNEL_CLIENT, + NULL, NULL, + "channel", channel, + "client", client, + "stream", stream, + "monitor-latency", monitor_latency, + "caps", caps_array, + "common-caps", common_caps_array, + NULL); - rcc->incoming.header.data = rcc->incoming.header_buf; - rcc->incoming.serial = 1; - ring_init(&rcc->pipe); + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); - rcc->dummy = TRUE; - rcc->dummy_connected = TRUE; - red_channel_add_client(channel, rcc); - red_client_add_channel(client, rcc); - pthread_mutex_unlock(&client->lock); return rcc; -error: - pthread_mutex_unlock(&client->lock); - return NULL; } void red_channel_client_seamless_migration_done(RedChannelClient *rcc) { - rcc->wait_migrate_data = FALSE; + rcc->priv->wait_migrate_data = FALSE; - if (red_client_seamless_migration_done_for_channel(rcc->client, rcc)) { - if (rcc->latency_monitor.timer) { + if (red_client_seamless_migration_done_for_channel(rcc->priv->client, rcc)) { + if (rcc->priv->latency_monitor.timer) { red_channel_client_start_ping_timer(rcc, PING_TEST_IDLE_NET_TIMEOUT_MS); } - if (rcc->connectivity_monitor.timer) { - rcc->channel->core->timer_start(rcc->connectivity_monitor.timer, - rcc->connectivity_monitor.timeout); + if (rcc->priv->connectivity_monitor.timer) { + rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer, + rcc->priv->connectivity_monitor.timeout); } } } void red_channel_client_semi_seamless_migration_complete(RedChannelClient *rcc) { - if (rcc->latency_monitor.timer) { + if (rcc->priv->latency_monitor.timer) { red_channel_client_start_ping_timer(rcc, PING_TEST_IDLE_NET_TIMEOUT_MS); } } int red_channel_client_waits_for_migrate_data(RedChannelClient *rcc) { - return rcc->wait_migrate_data; + return rcc->priv->wait_migrate_data; } void red_channel_client_default_migrate(RedChannelClient *rcc) { - if (rcc->latency_monitor.timer) { + if (rcc->priv->latency_monitor.timer) { red_channel_client_cancel_ping_timer(rcc); - rcc->channel->core->timer_remove(rcc->latency_monitor.timer); - rcc->latency_monitor.timer = NULL; + rcc->priv->channel->core->timer_remove(rcc->priv->latency_monitor.timer); + rcc->priv->latency_monitor.timer = NULL; } - if (rcc->connectivity_monitor.timer) { - rcc->channel->core->timer_remove(rcc->connectivity_monitor.timer); - rcc->connectivity_monitor.timer = NULL; + if (rcc->priv->connectivity_monitor.timer) { + rcc->priv->channel->core->timer_remove(rcc->priv->connectivity_monitor.timer); + rcc->priv->connectivity_monitor.timer = NULL; } red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MIGRATE); } -void red_channel_client_ref(RedChannelClient *rcc) -{ - rcc->refs++; -} - -void red_channel_client_unref(RedChannelClient *rcc) -{ - spice_debug("rcc=%p", rcc); - - if (--rcc->refs) - return; - - reds_stream_free(rcc->stream); - rcc->stream = NULL; - - if (rcc->send_data.main.marshaller) - spice_marshaller_destroy(rcc->send_data.main.marshaller); - - if (rcc->send_data.urgent.marshaller) - spice_marshaller_destroy(rcc->send_data.urgent.marshaller); - - red_channel_client_destroy_remote_caps(rcc); - if (rcc->channel) - red_channel_unref(rcc->channel); - - free(rcc); -} - void red_channel_client_destroy(RedChannelClient *rcc) { - rcc->destroying = TRUE; + rcc->priv->destroying = TRUE; red_channel_client_disconnect(rcc); - red_client_remove_channel(rcc->client, rcc); - red_channel_client_unref(rcc); + red_client_remove_channel(rcc->priv->client, rcc); + g_object_unref(rcc); } void red_channel_client_shutdown(RedChannelClient *rcc) { - if (rcc->stream && !rcc->stream->shutdown) { - rcc->channel->core->watch_remove(rcc->stream->watch); - rcc->stream->watch = NULL; - shutdown(rcc->stream->socket, SHUT_RDWR); - rcc->stream->shutdown = TRUE; + if (rcc->priv->stream && !rcc->priv->stream->shutdown) { + rcc->priv->channel->core->watch_remove(rcc->priv->stream->watch); + rcc->priv->stream->watch = NULL; + shutdown(rcc->priv->stream->socket, SHUT_RDWR); + rcc->priv->stream->shutdown = TRUE; } } @@ -1028,25 +1203,25 @@ static void red_peer_handle_incoming(RedsStream *stream, IncomingHandler *handle void red_channel_client_receive(RedChannelClient *rcc) { - red_channel_client_ref(rcc); - red_peer_handle_incoming(rcc->stream, &rcc->incoming); - red_channel_client_unref(rcc); + g_object_ref(rcc); + red_peer_handle_incoming(rcc->priv->stream, &rcc->incoming); + g_object_unref(rcc); } void red_channel_client_send(RedChannelClient *rcc) { - red_channel_client_ref(rcc); - red_peer_handle_outgoing(rcc->stream, &rcc->outgoing); - red_channel_client_unref(rcc); + g_object_ref(rcc); + red_peer_handle_outgoing(rcc->priv->stream, &rcc->outgoing); + g_object_unref(rcc); } static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc) { PipeItem *item; - if (!rcc || rcc->send_data.blocked + if (!rcc || rcc->priv->send_data.blocked || red_channel_client_waiting_for_ack(rcc) - || !(item = (PipeItem *)ring_get_tail(&rcc->pipe))) { + || !(item = (PipeItem *)ring_get_tail(&rcc->priv->pipe))) { return NULL; } red_channel_client_pipe_remove(rcc, item); @@ -1057,39 +1232,39 @@ void red_channel_client_push(RedChannelClient *rcc) { PipeItem *pipe_item; - if (!rcc->during_send) { - rcc->during_send = TRUE; + if (!rcc->priv->during_send) { + rcc->priv->during_send = TRUE; } else { return; } - red_channel_client_ref(rcc); - if (rcc->send_data.blocked) { + g_object_ref(rcc); + if (rcc->priv->send_data.blocked) { red_channel_client_send(rcc); } - if (!red_channel_client_no_item_being_sent(rcc) && !rcc->send_data.blocked) { - rcc->send_data.blocked = TRUE; + if (!red_channel_client_no_item_being_sent(rcc) && !rcc->priv->send_data.blocked) { + rcc->priv->send_data.blocked = TRUE; spice_printerr("ERROR: an item waiting to be sent and not blocked"); } while ((pipe_item = red_channel_client_pipe_item_get(rcc))) { red_channel_client_send_item(rcc, pipe_item); } - rcc->during_send = FALSE; - red_channel_client_unref(rcc); + rcc->priv->during_send = FALSE; + g_object_unref(rcc); } int red_channel_client_get_roundtrip_ms(RedChannelClient *rcc) { - if (rcc->latency_monitor.roundtrip < 0) { - return rcc->latency_monitor.roundtrip; + if (rcc->priv->latency_monitor.roundtrip < 0) { + return rcc->priv->latency_monitor.roundtrip; } - return rcc->latency_monitor.roundtrip / 1000 / 1000; + return rcc->priv->latency_monitor.roundtrip / 1000 / 1000; } void red_channel_client_init_outgoing_messages_window(RedChannelClient *rcc) { - rcc->ack_data.messages_window = 0; + rcc->priv->ack_data.messages_window = 0; red_channel_client_push(rcc); } @@ -1100,28 +1275,28 @@ static void red_channel_client_handle_pong(RedChannelClient *rcc, SpiceMsgPing * /* ignoring unexpected pongs, or post-migration pongs for pings that * started just before migration */ - if (ping->id != rcc->latency_monitor.id) { + if (ping->id != rcc->priv->latency_monitor.id) { spice_warning("ping-id (%u)!= pong-id %u", - rcc->latency_monitor.id, ping->id); + rcc->priv->latency_monitor.id, ping->id); return; } clock_gettime(CLOCK_MONOTONIC, &ts); now = ts.tv_sec * 1000000000LL + ts.tv_nsec; - if (rcc->latency_monitor.state == PING_STATE_WARMUP) { - rcc->latency_monitor.state = PING_STATE_LATENCY; + if (rcc->priv->latency_monitor.state == PING_STATE_WARMUP) { + rcc->priv->latency_monitor.state = PING_STATE_LATENCY; return; - } else if (rcc->latency_monitor.state != PING_STATE_LATENCY) { + } else if (rcc->priv->latency_monitor.state != PING_STATE_LATENCY) { spice_warning("unexpected"); return; } /* set TCO_NODELAY=0, in case we reverted it for the test*/ - if (!rcc->latency_monitor.tcp_nodelay) { + if (!rcc->priv->latency_monitor.tcp_nodelay) { int delay_val = 0; - if (setsockopt(rcc->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, + if (setsockopt(rcc->priv->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) { if (errno != ENOTSUP) { spice_warning("setsockopt failed, %s", strerror(errno)); @@ -1135,14 +1310,14 @@ static void red_channel_client_handle_pong(RedChannelClient *rcc, SpiceMsgPing * * threads or processes that are utilizing the network. We update the roundtrip * measurement with the minimal value we encountered till now. */ - if (rcc->latency_monitor.roundtrip < 0 || - now - ping->timestamp < rcc->latency_monitor.roundtrip) { - rcc->latency_monitor.roundtrip = now - ping->timestamp; - spice_debug("update roundtrip %.2f(ms)", rcc->latency_monitor.roundtrip/1000.0/1000.0); + if (rcc->priv->latency_monitor.roundtrip < 0 || + now - ping->timestamp < rcc->priv->latency_monitor.roundtrip) { + rcc->priv->latency_monitor.roundtrip = now - ping->timestamp; + spice_debug("update roundtrip %.2f(ms)", rcc->priv->latency_monitor.roundtrip/1000.0/1000.0); } - rcc->latency_monitor.last_pong_time = now; - rcc->latency_monitor.state = PING_STATE_NONE; + rcc->priv->latency_monitor.last_pong_time = now; + rcc->priv->latency_monitor.state = PING_STATE_NONE; red_channel_client_start_ping_timer(rcc, PING_TEST_TIMEOUT_MS); } @@ -1194,23 +1369,23 @@ int red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size, spice_printerr("bad message size"); return FALSE; } - rcc->ack_data.client_generation = *(uint32_t *)(message); + rcc->priv->ack_data.client_generation = *(uint32_t *)(message); break; case SPICE_MSGC_ACK: - if (rcc->ack_data.client_generation == rcc->ack_data.generation) { - rcc->ack_data.messages_window -= rcc->ack_data.client_window; + if (rcc->priv->ack_data.client_generation == rcc->priv->ack_data.generation) { + rcc->priv->ack_data.messages_window -= rcc->priv->ack_data.client_window; red_channel_client_push(rcc); } break; case SPICE_MSGC_DISCONNECTING: break; case SPICE_MSGC_MIGRATE_FLUSH_MARK: - if (!rcc->wait_migrate_flush_mark) { + if (!rcc->priv->wait_migrate_flush_mark) { spice_error("unexpected flush mark"); return FALSE; } red_channel_handle_migrate_flush_mark(rcc); - rcc->wait_migrate_flush_mark = FALSE; + rcc->priv->wait_migrate_flush_mark = FALSE; break; case SPICE_MSGC_MIGRATE_DATA: red_channel_handle_migrate_data(rcc, size, message); @@ -1229,19 +1404,19 @@ void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, { spice_assert(red_channel_client_no_item_being_sent(rcc)); spice_assert(msg_type != 0); - rcc->send_data.header.set_msg_type(&rcc->send_data.header, msg_type); - rcc->send_data.item = item; + rcc->priv->send_data.header.set_msg_type(&rcc->priv->send_data.header, msg_type); + rcc->priv->send_data.item = item; if (item) { - rcc->channel->channel_cbs.hold_item(rcc, item); + rcc->priv->channel->channel_cbs.hold_item(rcc, item); } } void red_channel_client_begin_send_message(RedChannelClient *rcc) { - SpiceMarshaller *m = rcc->send_data.marshaller; + SpiceMarshaller *m = rcc->priv->send_data.marshaller; // TODO - better check: type in channel_allowed_types. Better: type in channel_allowed_types(channel_state) - if (rcc->send_data.header.get_msg_type(&rcc->send_data.header) == 0) { + if (rcc->priv->send_data.header.get_msg_type(&rcc->priv->send_data.header) == 0) { spice_printerr("BUG: header->type == 0"); return; } @@ -1250,37 +1425,37 @@ void red_channel_client_begin_send_message(RedChannelClient *rcc) red_channel_client_cancel_ping_timer(rcc); spice_marshaller_flush(m); - rcc->send_data.size = spice_marshaller_get_total_size(m); - rcc->send_data.header.set_msg_size(&rcc->send_data.header, - rcc->send_data.size - rcc->send_data.header.header_size); - rcc->ack_data.messages_window++; - rcc->send_data.last_sent_serial = rcc->send_data.serial; - rcc->send_data.header.data = NULL; /* avoid writing to this until we have a new message */ + rcc->priv->send_data.size = spice_marshaller_get_total_size(m); + rcc->priv->send_data.header.set_msg_size(&rcc->priv->send_data.header, + rcc->priv->send_data.size - rcc->priv->send_data.header.header_size); + rcc->priv->ack_data.messages_window++; + rcc->priv->send_data.last_sent_serial = rcc->priv->send_data.serial; + rcc->priv->send_data.header.data = NULL; /* avoid writing to this until we have a new message */ red_channel_client_send(rcc); } SpiceMarshaller *red_channel_client_switch_to_urgent_sender(RedChannelClient *rcc) { spice_assert(red_channel_client_no_item_being_sent(rcc)); - spice_assert(rcc->send_data.header.data != NULL); - rcc->send_data.main.header_data = rcc->send_data.header.data; - rcc->send_data.main.item = rcc->send_data.item; + spice_assert(rcc->priv->send_data.header.data != NULL); + rcc->priv->send_data.main.header_data = rcc->priv->send_data.header.data; + rcc->priv->send_data.main.item = rcc->priv->send_data.item; - rcc->send_data.marshaller = rcc->send_data.urgent.marshaller; - rcc->send_data.item = NULL; + rcc->priv->send_data.marshaller = rcc->priv->send_data.urgent.marshaller; + rcc->priv->send_data.item = NULL; red_channel_client_reset_send_data(rcc); - return rcc->send_data.marshaller; + return rcc->priv->send_data.marshaller; } uint64_t red_channel_client_get_message_serial(RedChannelClient *rcc) { - return rcc->send_data.serial; + return rcc->priv->send_data.serial; } void red_channel_client_set_message_serial(RedChannelClient *rcc, uint64_t serial) { - rcc->send_data.last_sent_serial = serial; - rcc->send_data.serial = serial; + rcc->priv->send_data.last_sent_serial = serial; + rcc->priv->send_data.serial = serial; } static inline int validate_pipe_add(RedChannelClient *rcc, PipeItem *item) @@ -1300,8 +1475,8 @@ void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item) if (!validate_pipe_add(rcc, item)) { return; } - rcc->pipe_size++; - ring_add(&rcc->pipe, &item->link); + rcc->priv->pipe_size++; + ring_add(&rcc->priv->pipe, &item->link); } void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item) @@ -1317,7 +1492,7 @@ void red_channel_client_pipe_add_after(RedChannelClient *rcc, if (!validate_pipe_add(rcc, item)) { return; } - rcc->pipe_size++; + rcc->priv->pipe_size++; ring_add_after(&item->link, &pos->link); } @@ -1333,8 +1508,8 @@ void red_channel_client_pipe_add_tail_no_push(RedChannelClient *rcc, if (!validate_pipe_add(rcc, item)) { return; } - rcc->pipe_size++; - ring_add_before(&item->link, &rcc->pipe); + rcc->priv->pipe_size++; + ring_add_before(&item->link, &rcc->priv->pipe); } void red_channel_client_pipe_add_tail(RedChannelClient *rcc, PipeItem *item) @@ -1342,8 +1517,8 @@ void red_channel_client_pipe_add_tail(RedChannelClient *rcc, PipeItem *item) if (!validate_pipe_add(rcc, item)) { return; } - rcc->pipe_size++; - ring_add_before(&item->link, &rcc->pipe); + rcc->priv->pipe_size++; + ring_add_before(&item->link, &rcc->priv->pipe); red_channel_client_push(rcc); } @@ -1369,33 +1544,37 @@ void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type) gboolean red_channel_client_pipe_is_empty(RedChannelClient *rcc) { g_return_val_if_fail(rcc != NULL, TRUE); - return (rcc->pipe_size == 0) && (ring_is_empty(&rcc->pipe)); + return (rcc->priv->pipe_size == 0) && (ring_is_empty(&rcc->priv->pipe)); } uint32_t red_channel_client_get_pipe_size(RedChannelClient *rcc) { - return rcc->pipe_size; + return rcc->priv->pipe_size; } -int red_channel_client_is_connected(RedChannelClient *rcc) +static gboolean red_channel_client_default_is_connected(RedChannelClient *rcc) { - if (!rcc->dummy) { - return (rcc->stream != NULL) - && rcc->channel - && (g_list_find(rcc->channel->clients, rcc) != NULL); - } else { - return rcc->dummy_connected; - } + return (rcc->priv->stream != NULL) + && rcc->priv->channel + && (g_list_find(rcc->priv->channel->clients, rcc) != NULL); +} + +gboolean red_channel_client_is_connected(RedChannelClient *rcc) +{ + RedChannelClientClass *klass = RED_CHANNEL_CLIENT_GET_CLASS(rcc); + + g_return_val_if_fail(klass->is_connected != NULL, FALSE); + return klass->is_connected(rcc); } static void red_channel_client_clear_sent_item(RedChannelClient *rcc) { - if (rcc->send_data.item) { - red_channel_client_release_item(rcc, rcc->send_data.item, TRUE); - rcc->send_data.item = NULL; + if (rcc->priv->send_data.item) { + red_channel_client_release_item(rcc, rcc->priv->send_data.item, TRUE); + rcc->priv->send_data.item = NULL; } - rcc->send_data.blocked = FALSE; - rcc->send_data.size = 0; + rcc->priv->send_data.blocked = FALSE; + rcc->priv->send_data.size = 0; } static void red_channel_client_pipe_clear(RedChannelClient *rcc) @@ -1405,21 +1584,21 @@ static void red_channel_client_pipe_clear(RedChannelClient *rcc) if (rcc) { red_channel_client_clear_sent_item(rcc); } - while ((item = (PipeItem *)ring_get_head(&rcc->pipe))) { + while ((item = (PipeItem *)ring_get_head(&rcc->priv->pipe))) { ring_remove(&item->link); red_channel_client_release_item(rcc, item, FALSE); } - rcc->pipe_size = 0; + rcc->priv->pipe_size = 0; } void red_channel_client_ack_zero_messages_window(RedChannelClient *rcc) { - rcc->ack_data.messages_window = 0; + rcc->priv->ack_data.messages_window = 0; } void red_channel_client_ack_set_client_window(RedChannelClient *rcc, int client_window) { - rcc->ack_data.client_window = client_window; + rcc->priv->ack_data.client_window = client_window; } void red_channel_client_push_set_ack(RedChannelClient *rcc) @@ -1427,77 +1606,68 @@ void red_channel_client_push_set_ack(RedChannelClient *rcc) red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SET_ACK); } -static void red_channel_client_disconnect_dummy(RedChannelClient *rcc) +static void red_channel_client_default_disconnect(RedChannelClient *rcc) { - RedChannel *channel = red_channel_client_get_channel(rcc); - GList *link; - spice_assert(rcc->dummy); - if (channel && (link = g_list_find(channel->clients, rcc))) { - spice_printerr("rcc=%p (channel=%p type=%d id=%d)", rcc, channel, - channel->type, channel->id); - red_channel_remove_client(channel, link->data); - } - rcc->dummy_connected = FALSE; -} + RedChannel *channel = rcc->priv->channel; -void red_channel_client_disconnect(RedChannelClient *rcc) -{ - RedChannel *channel = rcc->channel; - - if (rcc->dummy) { - red_channel_client_disconnect_dummy(rcc); - return; - } if (!red_channel_client_is_connected(rcc)) { return; } spice_printerr("rcc=%p (channel=%p type=%d id=%d)", rcc, channel, channel->type, channel->id); red_channel_client_pipe_clear(rcc); - if (rcc->stream->watch) { - channel->core->watch_remove(rcc->stream->watch); - rcc->stream->watch = NULL; + if (rcc->priv->stream->watch) { + channel->core->watch_remove(rcc->priv->stream->watch); + rcc->priv->stream->watch = NULL; } - if (rcc->latency_monitor.timer) { - channel->core->timer_remove(rcc->latency_monitor.timer); - rcc->latency_monitor.timer = NULL; + if (rcc->priv->latency_monitor.timer) { + channel->core->timer_remove(rcc->priv->latency_monitor.timer); + rcc->priv->latency_monitor.timer = NULL; } - if (rcc->connectivity_monitor.timer) { - channel->core->timer_remove(rcc->connectivity_monitor.timer); - rcc->connectivity_monitor.timer = NULL; + if (rcc->priv->connectivity_monitor.timer) { + channel->core->timer_remove(rcc->priv->connectivity_monitor.timer); + rcc->priv->connectivity_monitor.timer = NULL; } red_channel_remove_client(channel, rcc); channel->channel_cbs.on_disconnect(rcc); } +void red_channel_client_disconnect(RedChannelClient *rcc) +{ + RedChannelClientClass *klass = RED_CHANNEL_CLIENT_GET_CLASS(rcc); + + g_return_if_fail(klass->is_connected != NULL); + klass->disconnect(rcc); +} + int red_channel_client_is_blocked(RedChannelClient *rcc) { - return rcc && rcc->send_data.blocked; + return rcc && rcc->priv->send_data.blocked; } int red_channel_client_send_message_pending(RedChannelClient *rcc) { - return rcc->send_data.header.get_msg_type(&rcc->send_data.header) != 0; + return rcc->priv->send_data.header.get_msg_type(&rcc->priv->send_data.header) != 0; } SpiceMarshaller *red_channel_client_get_marshaller(RedChannelClient *rcc) { - return rcc->send_data.marshaller; + return rcc->priv->send_data.marshaller; } RedsStream *red_channel_client_get_stream(RedChannelClient *rcc) { - return rcc->stream; + return rcc->priv->stream; } RedClient *red_channel_client_get_client(RedChannelClient *rcc) { - return rcc->client; + return rcc->priv->client; } void red_channel_client_set_header_sub_list(RedChannelClient *rcc, uint32_t sub_list) { - rcc->send_data.header.set_msg_sub_list(&rcc->send_data.header, sub_list); + rcc->priv->send_data.header.set_msg_sub_list(&rcc->priv->send_data.header, sub_list); } /* TODO: more evil sync stuff. anything with the word wait in it's name. */ @@ -1516,7 +1686,7 @@ int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc, end_time = UINT64_MAX; } - rcc->channel->channel_cbs.hold_item(rcc, item); + rcc->priv->channel->channel_cbs.hold_item(rcc, item); if (red_channel_client_is_blocked(rcc)) { red_channel_client_receive(rcc); @@ -1576,7 +1746,7 @@ int red_channel_client_wait_outgoing_item(RedChannelClient *rcc, void red_channel_client_disconnect_if_pending_send(RedChannelClient *rcc) { - if (red_channel_client_is_blocked(rcc) || rcc->pipe_size > 0) { + if (red_channel_client_is_blocked(rcc) || rcc->priv->pipe_size > 0) { red_channel_client_disconnect(rcc); } else { spice_assert(red_channel_client_no_item_being_sent(rcc)); @@ -1587,7 +1757,7 @@ void red_channel_client_disconnect_if_pending_send(RedChannelClient *rcc) gboolean red_channel_client_no_item_being_sent(RedChannelClient *rcc) { - return !rcc || (rcc->send_data.size == 0); + return !rcc || (rcc->priv->send_data.size == 0); } void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc, @@ -1602,22 +1772,27 @@ gboolean red_channel_client_set_migration_seamless(RedChannelClient *rcc) { gboolean ret = FALSE; - if (rcc->channel->migration_flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) { - rcc->wait_migrate_data = TRUE; + if (rcc->priv->channel->migration_flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) { + rcc->priv->wait_migrate_data = TRUE; ret = TRUE; } - spice_debug("channel type %d id %d rcc %p wait data %d", rcc->channel->type, rcc->channel->id, rcc, - rcc->wait_migrate_data); + spice_debug("channel type %d id %d rcc %p wait data %d", rcc->priv->channel->type, rcc->priv->channel->id, rcc, + rcc->priv->wait_migrate_data); return ret; } void red_channel_client_set_destroying(RedChannelClient *rcc) { - rcc->destroying = TRUE; + rcc->priv->destroying = TRUE; } gboolean red_channel_client_is_destroying(RedChannelClient *rcc) { - return rcc->destroying; + return rcc->priv->destroying; +} + +GQuark spice_server_error_quark(void) +{ + return g_quark_from_static_string("spice-server-error-quark"); } diff --git a/server/red-channel-client.h b/server/red-channel-client.h index c72e8eef..76f11152 100644 --- a/server/red-channel-client.h +++ b/server/red-channel-client.h @@ -18,15 +18,141 @@ #ifndef _H_RED_CHANNEL_CLIENT #define _H_RED_CHANNEL_CLIENT +#include <glib-object.h> +#include <gio/gio.h> + +#include <spice/protocol.h> + #include "common/marshaller.h" +#include "demarshallers.h" #include "red-pipe-item.h" #include "reds-stream.h" +G_BEGIN_DECLS + +#define MAX_HEADER_SIZE sizeof(SpiceDataHeader) +#define CLIENT_ACK_WINDOW 20 + +#ifndef IOV_MAX +#define IOV_MAX 1024 +#endif + + +#define RED_TYPE_CHANNEL_CLIENT red_channel_client_get_type() + +#define RED_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), RED_TYPE_CHANNEL_CLIENT, RedChannelClient)) +#define RED_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), RED_TYPE_CHANNEL_CLIENT, RedChannelClientClass)) +#define RED_IS_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), RED_TYPE_CHANNEL_CLIENT)) +#define RED_IS_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), RED_TYPE_CHANNEL_CLIENT)) +#define RED_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), RED_TYPE_CHANNEL_CLIENT, RedChannelClientClass)) + typedef struct RedChannel RedChannel; typedef struct RedClient RedClient; typedef struct IncomingHandler IncomingHandler; -typedef struct RedChannelClient RedChannelClient; +typedef struct _RedChannelClient RedChannelClient; +typedef struct _RedChannelClientClass RedChannelClientClass; +typedef struct _RedChannelClientPrivate RedChannelClientPrivate; + +typedef struct SpiceDataHeaderOpaque SpiceDataHeaderOpaque; + +typedef uint16_t (*get_msg_type_proc)(SpiceDataHeaderOpaque *header); +typedef uint32_t (*get_msg_size_proc)(SpiceDataHeaderOpaque *header); +typedef void (*set_msg_type_proc)(SpiceDataHeaderOpaque *header, uint16_t type); +typedef void (*set_msg_size_proc)(SpiceDataHeaderOpaque *header, uint32_t size); +typedef void (*set_msg_serial_proc)(SpiceDataHeaderOpaque *header, uint64_t serial); +typedef void (*set_msg_sub_list_proc)(SpiceDataHeaderOpaque *header, uint32_t sub_list); + +struct SpiceDataHeaderOpaque { + uint8_t *data; + uint16_t header_size; + + set_msg_type_proc set_msg_type; + set_msg_size_proc set_msg_size; + set_msg_serial_proc set_msg_serial; + set_msg_sub_list_proc set_msg_sub_list; + + get_msg_type_proc get_msg_type; + get_msg_size_proc get_msg_size; +}; + +typedef int (*handle_message_proc)(void *opaque, + uint16_t type, uint32_t size, uint8_t *msg); +typedef int (*handle_parsed_proc)(void *opaque, uint32_t size, uint16_t type, void *message); +typedef uint8_t *(*alloc_msg_recv_buf_proc)(void *opaque, uint16_t type, uint32_t size); +typedef void (*release_msg_recv_buf_proc)(void *opaque, + uint16_t type, uint32_t size, uint8_t *msg); +typedef void (*on_incoming_error_proc)(void *opaque); +typedef void (*on_input_proc)(void *opaque, int n); + +typedef struct IncomingHandlerInterface { + handle_message_proc handle_message; + alloc_msg_recv_buf_proc alloc_msg_buf; + on_incoming_error_proc on_error; // recv error or handle_message error + release_msg_recv_buf_proc release_msg_buf; // for errors + // The following is an optional alternative to handle_message, used if not null + spice_parse_channel_func_t parser; + handle_parsed_proc handle_parsed; + on_input_proc on_input; +} IncomingHandlerInterface; + +typedef struct IncomingHandler { + IncomingHandlerInterface *cb; + void *opaque; + uint8_t header_buf[MAX_HEADER_SIZE]; + SpiceDataHeaderOpaque header; + uint32_t header_pos; + uint8_t *msg; // data of the msg following the header. allocated by alloc_msg_buf. + uint32_t msg_pos; + uint64_t serial; +} IncomingHandler; + +typedef int (*get_outgoing_msg_size_proc)(void *opaque); +typedef void (*prepare_outgoing_proc)(void *opaque, struct iovec *vec, int *vec_size, int pos); +typedef void (*on_outgoing_error_proc)(void *opaque); +typedef void (*on_outgoing_block_proc)(void *opaque); +typedef void (*on_outgoing_msg_done_proc)(void *opaque); +typedef void (*on_output_proc)(void *opaque, int n); + +typedef struct OutgoingHandlerInterface { + get_outgoing_msg_size_proc get_msg_size; + prepare_outgoing_proc prepare; + on_outgoing_error_proc on_error; + on_outgoing_block_proc on_block; + on_outgoing_msg_done_proc on_msg_done; + on_output_proc on_output; +} OutgoingHandlerInterface; + +typedef struct OutgoingHandler { + OutgoingHandlerInterface *cb; + void *opaque; + struct iovec vec_buf[IOV_MAX]; + int vec_size; + struct iovec *vec; + int pos; + int size; +} OutgoingHandler; + +struct _RedChannelClient +{ + GObject parent; + + /* protected */ + OutgoingHandler outgoing; + IncomingHandler incoming; + + RedChannelClientPrivate *priv; +}; + +struct _RedChannelClientClass +{ + GObjectClass parent_class; + + gboolean (*is_connected)(RedChannelClient *rcc); + void (*disconnect)(RedChannelClient *rcc); +}; + +GType red_channel_client_get_type(void) G_GNUC_CONST; /* * When an error occurs over a channel, we treat it as a warning @@ -40,22 +166,13 @@ typedef struct RedChannelClient RedChannelClient; red_channel_client_shutdown(rcc); \ } while (0) -RedChannelClient *red_channel_client_create(int size, RedChannel *channel, +RedChannelClient *red_channel_client_create(RedChannel *channel, RedClient *client, RedsStream *stream, int monitor_latency, int num_common_caps, uint32_t *common_caps, int num_caps, uint32_t *caps); -RedChannelClient *red_channel_client_create_dummy(int size, - RedChannel *channel, - RedClient *client, - int num_common_caps, uint32_t *common_caps, - int num_caps, uint32_t *caps); - -void red_channel_client_ref(RedChannelClient *rcc); -void red_channel_client_unref(RedChannelClient *rcc); - -int red_channel_client_is_connected(RedChannelClient *rcc); +gboolean red_channel_client_is_connected(RedChannelClient *rcc); void red_channel_client_default_migrate(RedChannelClient *rcc); int red_channel_client_waits_for_migrate_data(RedChannelClient *rcc); void red_channel_client_destroy(RedChannelClient *rcc); @@ -171,6 +288,28 @@ gboolean red_channel_client_set_migration_seamless(RedChannelClient *rcc); void red_channel_client_set_destroying(RedChannelClient *rcc); gboolean red_channel_client_is_destroying(RedChannelClient *rcc); -#define RED_CHANNEL_CLIENT(Client) ((RedChannelClient *)(Client)) +#define SPICE_SERVER_ERROR spice_server_error_quark() +GQuark spice_server_error_quark(void); + +typedef enum +{ + SPICE_SERVER_ERROR_FAILED +} SpiceServerError; + +/* Messages handled by red_channel + * SET_ACK - sent to client on channel connection + * Note that the numbers don't have to correspond to spice message types, + * 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, + + PIPE_ITEM_TYPE_CHANNEL_BASE=101, +}; + +G_END_DECLS #endif /* _H_RED_CHANNEL_CLIENT */ diff --git a/server/red-channel.h b/server/red-channel.h index 96f982c9..0e1307a9 100644 --- a/server/red-channel.h +++ b/server/red-channel.h @@ -30,124 +30,17 @@ #include "spice.h" #include "common.h" -#include "demarshallers.h" +#include "main-channel-client.h" #include "reds-stream.h" #include "stat.h" #include "red-pipe-item.h" #include "red-channel-client.h" -#define MAX_SEND_BUFS 1000 -#define CLIENT_ACK_WINDOW 20 - -#ifndef IOV_MAX -#define IOV_MAX 1024 -#endif - -#define MAX_HEADER_SIZE sizeof(SpiceDataHeader) - -/* Basic interface for channels, without using the RedChannel interface. - The intention is to move towards one channel interface gradually. - At the final stage, this interface shouldn't be exposed. Only RedChannel will use it. */ - -typedef struct SpiceDataHeaderOpaque SpiceDataHeaderOpaque; - -typedef uint16_t (*get_msg_type_proc)(SpiceDataHeaderOpaque *header); -typedef uint32_t (*get_msg_size_proc)(SpiceDataHeaderOpaque *header); -typedef void (*set_msg_type_proc)(SpiceDataHeaderOpaque *header, uint16_t type); -typedef void (*set_msg_size_proc)(SpiceDataHeaderOpaque *header, uint32_t size); -typedef void (*set_msg_serial_proc)(SpiceDataHeaderOpaque *header, uint64_t serial); -typedef void (*set_msg_sub_list_proc)(SpiceDataHeaderOpaque *header, uint32_t sub_list); - -struct SpiceDataHeaderOpaque { - uint8_t *data; - uint16_t header_size; - - set_msg_type_proc set_msg_type; - set_msg_size_proc set_msg_size; - set_msg_serial_proc set_msg_serial; - set_msg_sub_list_proc set_msg_sub_list; - - get_msg_type_proc get_msg_type; - get_msg_size_proc get_msg_size; -}; - -typedef int (*handle_message_proc)(void *opaque, - uint16_t type, uint32_t size, uint8_t *msg); -typedef int (*handle_parsed_proc)(void *opaque, uint32_t size, uint16_t type, void *message); -typedef uint8_t *(*alloc_msg_recv_buf_proc)(void *opaque, uint16_t type, uint32_t size); -typedef void (*release_msg_recv_buf_proc)(void *opaque, - uint16_t type, uint32_t size, uint8_t *msg); -typedef void (*on_incoming_error_proc)(void *opaque); -typedef void (*on_input_proc)(void *opaque, int n); - -typedef struct IncomingHandlerInterface { - handle_message_proc handle_message; - alloc_msg_recv_buf_proc alloc_msg_buf; - on_incoming_error_proc on_error; // recv error or handle_message error - release_msg_recv_buf_proc release_msg_buf; // for errors - // The following is an optional alternative to handle_message, used if not null - spice_parse_channel_func_t parser; - handle_parsed_proc handle_parsed; - on_input_proc on_input; -} IncomingHandlerInterface; - -typedef struct IncomingHandler { - IncomingHandlerInterface *cb; - void *opaque; - uint8_t header_buf[MAX_HEADER_SIZE]; - SpiceDataHeaderOpaque header; - uint32_t header_pos; - uint8_t *msg; // data of the msg following the header. allocated by alloc_msg_buf. - uint32_t msg_pos; - uint64_t serial; -} IncomingHandler; - -typedef int (*get_outgoing_msg_size_proc)(void *opaque); -typedef void (*prepare_outgoing_proc)(void *opaque, struct iovec *vec, int *vec_size, int pos); -typedef void (*on_outgoing_error_proc)(void *opaque); -typedef void (*on_outgoing_block_proc)(void *opaque); -typedef void (*on_outgoing_msg_done_proc)(void *opaque); -typedef void (*on_output_proc)(void *opaque, int n); - -typedef struct OutgoingHandlerInterface { - get_outgoing_msg_size_proc get_msg_size; - prepare_outgoing_proc prepare; - on_outgoing_error_proc on_error; - on_outgoing_block_proc on_block; - on_outgoing_msg_done_proc on_msg_done; - on_output_proc on_output; -} OutgoingHandlerInterface; - -typedef struct OutgoingHandler { - OutgoingHandlerInterface *cb; - void *opaque; - struct iovec vec_buf[IOV_MAX]; - int vec_size; - struct iovec *vec; - int pos; - int size; -} OutgoingHandler; - /* Red Channel interface */ typedef struct RedsStream RedsStream; typedef struct RedChannel RedChannel; typedef struct RedClient RedClient; -typedef struct MainChannelClient MainChannelClient; - -/* Messages handled by red_channel - * SET_ACK - sent to client on channel connection - * Note that the numbers don't have to correspond to spice message types, - * 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, - - PIPE_ITEM_TYPE_CHANNEL_BASE=101, -}; typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannelClient *channel, uint16_t type, uint32_t size); diff --git a/server/red-worker.h b/server/red-worker.h index 2f49ba0f..c932544a 100644 --- a/server/red-worker.h +++ b/server/red-worker.h @@ -27,7 +27,6 @@ typedef struct RedWorker RedWorker; -#define COMMON_WORKER_CHANNEL_CLIENT(Client) ((CommonWorkerChannelClient*)(Client)) #define DISPLAY_CLIENT_TIMEOUT 30000000000ULL //nano #define CHANNEL_RECEIVE_BUF_SIZE 1024 diff --git a/server/reds.c b/server/reds.c index 514cd795..e7181fdc 100644 --- a/server/reds.c +++ b/server/reds.c @@ -873,8 +873,7 @@ static void vdi_port_on_free_self_token(RedCharDevice *device, gpointer opaque) static void vdi_port_remove_client(RedClient *client, void *opaque) { - red_channel_client_shutdown(main_channel_client_get_base( - red_client_get_main(client))); + red_channel_client_shutdown(RED_CHANNEL_CLIENT(red_client_get_main(client))); } /****************************************************************************/ @@ -989,7 +988,7 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t return; } spice_assert(reds->vdagent->st && reds->vdagent->st == dev_state); - rcc = main_channel_client_get_base(mcc); + rcc = RED_CHANNEL_CLIENT(mcc); client = red_channel_client_get_client(rcc); reds->agent_state->priv->client_agent_started = TRUE; /* @@ -1025,7 +1024,7 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens) { - RedClient *client = red_channel_client_get_client(main_channel_client_get_base(mcc)); + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); if (!reds->vdagent) { return; } @@ -1052,7 +1051,7 @@ uint8_t *reds_get_agent_data_buffer(RedsState *reds, MainChannelClient *mcc, siz } spice_assert(dev_state->priv->recv_from_client_buf == NULL); - client = red_channel_client_get_client(main_channel_client_get_base(mcc)); + client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); dev_state->priv->recv_from_client_buf = spice_char_device_write_buffer_get(RED_CHAR_DEVICE(dev_state), client, size + sizeof(VDIChunkHeader)); @@ -1130,7 +1129,7 @@ void reds_on_main_agent_data(RedsState *reds, MainChannelClient *mcc, void *mess reds_on_main_agent_monitors_config(reds, mcc, message, size); return; case AGENT_MSG_FILTER_PROTO_ERROR: - red_channel_client_shutdown(main_channel_client_get_base(mcc)); + red_channel_client_shutdown(RED_CHANNEL_CLIENT(mcc)); return; } @@ -1417,7 +1416,7 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc, } else { spice_debug("agent was not attached on the source host"); if (reds->vdagent) { - RedClient *client = red_channel_client_get_client(main_channel_client_get_base(mcc)); + RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)); /* spice_char_device_client_remove disables waiting for migration data */ spice_char_device_client_remove(RED_CHAR_DEVICE(agent_state), client); main_channel_push_agent_connected(reds->main_channel); @@ -1874,7 +1873,7 @@ int reds_on_migrate_dst_set_seamless(RedsState *reds, MainChannelClient *mcc, ui if (reds->allow_multiple_clients || src_version > SPICE_MIGRATION_PROTOCOL_VERSION) { reds->dst_do_seamless_migrate = FALSE; } else { - RedChannelClient *rcc = main_channel_client_get_base(mcc); + RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc); RedClient *client = red_channel_client_get_client(rcc); red_client_set_migration_seamless(client); diff --git a/server/reds.h b/server/reds.h index 7041085b..13990772 100644 --- a/server/reds.h +++ b/server/reds.h @@ -28,6 +28,7 @@ #include "common/messages.h" #include "spice.h" #include "red-channel.h" +#include "main-channel-client.h" #include "main-dispatcher.h" #include "migration-protocol.h" diff --git a/server/smartcard-channel-client.c b/server/smartcard-channel-client.c new file mode 100644 index 00000000..7b1ff5c5 --- /dev/null +++ b/server/smartcard-channel-client.c @@ -0,0 +1,415 @@ +/* + Copyright (C) 2009-2015 Red Hat, Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see <http://www.gnu.org/licenses/>. + */ + +#include "red-channel-client-private.h" +#include "smartcard-channel-client.h" + +G_DEFINE_TYPE(SmartCardChannelClient, smart_card_channel_client, RED_TYPE_CHANNEL_CLIENT) + +#define SMARTCARD_CHANNEL_CLIENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), TYPE_SMARTCARD_CHANNEL_CLIENT, SmartCardChannelClientPrivate)) + + struct _SmartCardChannelClientPrivate +{ + RedChannelClient base; + RedCharDeviceSmartcard *smartcard_state; + + /* read_from_client/write_to_device buffer. + * The beginning of the buffer should always be VSCMsgHeader*/ + SpiceCharDeviceWriteBuffer *write_buf; + int msg_in_write_buf; /* was the client msg received into a SpiceCharDeviceWriteBuffer + * or was it explicitly malloced */ +}; + +typedef struct ErrorItem { + PipeItem base; + VSCMsgHeader vheader; + VSCMsgError error; +} ErrorItem; + +static void smart_card_channel_client_get_property(GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void smart_card_channel_client_set_property(GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + } +} + +static void smart_card_channel_client_dispose(GObject *object) +{ + G_OBJECT_CLASS(smart_card_channel_client_parent_class)->dispose(object); +} + +static void smart_card_channel_client_finalize(GObject *object) +{ + SmartCardChannelClient *self = SMARTCARD_CHANNEL_CLIENT(object); + + if (self->priv->smartcard_state) + g_object_remove_weak_pointer(G_OBJECT(self->priv->smartcard_state), + (gpointer*)&self->priv->smartcard_state); + G_OBJECT_CLASS(smart_card_channel_client_parent_class)->finalize(object); +} + +static void smart_card_channel_client_class_init(SmartCardChannelClientClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(SmartCardChannelClientPrivate)); + + object_class->get_property = smart_card_channel_client_get_property; + object_class->set_property = smart_card_channel_client_set_property; + object_class->dispose = smart_card_channel_client_dispose; + object_class->finalize = smart_card_channel_client_finalize; +} + +static void +smart_card_channel_client_init(SmartCardChannelClient *self) +{ + self->priv = SMARTCARD_CHANNEL_CLIENT_PRIVATE(self); +} + +SmartCardChannelClient* smartcard_channel_client_create(RedChannel *channel, + RedClient *client, RedsStream *stream, + int monitor_latency, + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps) +{ + SmartCardChannelClient *rcc; + GArray *common_caps_array = NULL, *caps_array = NULL; + + if (common_caps) { + common_caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*common_caps), num_common_caps); + g_array_append_vals(common_caps_array, common_caps, num_common_caps); + } + if (caps) { + caps_array = g_array_sized_new(FALSE, FALSE, sizeof (*caps), num_caps); + g_array_append_vals(caps_array, caps, num_caps); + } + + rcc = g_initable_new(RED_TYPE_CHANNEL_CLIENT, + NULL, NULL, + "channel", channel, + "client", client, + "stream", stream, + "monitor-latency", monitor_latency, + "caps", caps_array, + "common-caps", common_caps_array, + NULL); + + if (caps_array) + g_array_unref(caps_array); + if (common_caps_array) + g_array_unref(common_caps_array); + + return rcc; +} + +uint8_t *smartcard_channel_client_alloc_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size) +{ + SmartCardChannelClient *scc = SMARTCARD_CHANNEL_CLIENT(rcc); + RedClient *client = red_channel_client_get_client(rcc); + + /* todo: only one reader is actually supported. When we fix the code to support + * multiple readers, we will porbably associate different devices to + * differenc channels */ + if (!scc->priv->smartcard_state) { + scc->priv->msg_in_write_buf = FALSE; + return spice_malloc(size); + } else { + RedCharDeviceSmartcard *smartcard; + + spice_assert(smartcard_get_n_readers() == 1); + smartcard = scc->priv->smartcard_state; + spice_assert(smartcard_char_device_get_client(smartcard) || scc->priv->smartcard_state); + spice_assert(!scc->priv->write_buf); + scc->priv->write_buf = + spice_char_device_write_buffer_get(RED_CHAR_DEVICE(smartcard), client, + size); + + if (!scc->priv->write_buf) { + spice_error("failed to allocate write buffer"); + return NULL; + } + scc->priv->msg_in_write_buf = TRUE; + return scc->priv->write_buf->buf; + } +} + +void smartcard_channel_client_release_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size, + uint8_t *msg) +{ + SmartCardChannelClient *scc = SMARTCARD_CHANNEL_CLIENT(rcc); + + /* todo: only one reader is actually supported. When we fix the code to support + * multiple readers, we will porbably associate different devices to + * differenc channels */ + + if (!scc->priv->msg_in_write_buf) { + spice_assert(!scc->priv->write_buf); + free(msg); + } else { + if (scc->priv->write_buf) { /* msg hasn't been pushed to the guest */ + spice_assert(scc->priv->write_buf->buf == msg); + spice_char_device_write_buffer_release(RED_CHAR_DEVICE(scc->priv->smartcard_state), + scc->priv->write_buf); + scc->priv->write_buf = NULL; + } + } +} + +void smartcard_channel_client_on_disconnect(RedChannelClient *rcc) +{ + SmartCardChannelClient *scc = SMARTCARD_CHANNEL_CLIENT(rcc); + RedCharDeviceSmartcard *device = scc->priv->smartcard_state; + + if (device) { + + smartcard_char_device_detach_client(device, scc); + smartcard_char_device_notify_reader_remove(device); + } +} + +void smartcard_channel_client_send_data(RedChannelClient *rcc, + SpiceMarshaller *m, + PipeItem *item, + VSCMsgHeader *vheader) +{ + spice_assert(rcc); + spice_assert(vheader); + red_channel_client_init_send_data(rcc, SPICE_MSG_SMARTCARD_DATA, item); + spice_marshaller_add_ref(m, (uint8_t*)vheader, sizeof(VSCMsgHeader)); + if (vheader->length > 0) { + spice_marshaller_add_ref(m, (uint8_t*)(vheader+1), vheader->length); + } +} + +void smartcard_channel_client_send_error(RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item) +{ + ErrorItem* error_item = (ErrorItem*)item; + + smartcard_channel_client_send_data(rcc, m, item, &error_item->vheader); +} + +static void smartcard_channel_client_push_error(RedChannelClient *rcc, + uint32_t reader_id, + VSCErrorCode error) +{ + ErrorItem *error_item = spice_new0(ErrorItem, 1); + + pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR); + + error_item->base.type = 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); + error_item->error.code = error; + red_channel_client_pipe_add_push(rcc, &error_item->base); +} + +void smartcard_channel_client_add_reader(SmartCardChannelClient *scc, + uint8_t *name) +{ + if (!scc->priv->smartcard_state) { /* we already tried to attach a reader to the client + when it connected */ + SpiceCharDeviceInstance *char_device = smartcard_readers_get_unattached(); + + if (!char_device) { + smartcard_channel_client_push_error(RED_CHANNEL_CLIENT(scc), + VSCARD_UNDEFINED_READER_ID, + VSC_CANNOT_ADD_MORE_READERS); + return; + } + smartcard_char_device_attach_client(char_device, scc); + } + smartcard_char_device_notify_reader_add(scc->priv->smartcard_state); + // The device sends a VSC_Error message, we will let it through, no + // need to send our own. We already set the correct reader_id, from + // our RedCharDeviceSmartcard. +} + +void smartcard_channel_client_remove_reader(SmartCardChannelClient *scc, + uint32_t reader_id) +{ + SpiceCharDeviceInstance *char_device = smartcard_readers_get(reader_id); + RedCharDeviceSmartcard *state; + + if (char_device == NULL) { + smartcard_channel_client_push_error(RED_CHANNEL_CLIENT(scc), + reader_id, VSC_GENERAL_ERROR); + return; + } + + state = spice_char_device_state_opaque_get(char_device->st); + spice_assert(scc->priv->smartcard_state == state); + if (!smartcard_char_device_notify_reader_remove(state)) { + smartcard_channel_client_push_error(RED_CHANNEL_CLIENT(scc), + reader_id, VSC_GENERAL_ERROR); + return; + } +} + +RedCharDeviceSmartcard* smartcard_channel_client_get_device(SmartCardChannelClient *scc) +{ + return scc->priv->smartcard_state; +} + +static void smartcard_channel_client_write_to_reader(SmartCardChannelClient *scc) +{ + g_return_if_fail(scc); + + smartcard_channel_write_to_reader(scc->priv->write_buf); + scc->priv->write_buf = NULL; +} + + +int smartcard_channel_client_handle_message(RedChannelClient *rcc, + uint16_t type, + uint32_t size, + uint8_t *msg) +{ + VSCMsgHeader* vheader = (VSCMsgHeader*)msg; + SmartCardChannelClient *scc = SMARTCARD_CHANNEL_CLIENT(rcc); + + if (type != SPICE_MSGC_SMARTCARD_DATA) { + /* Handles seamless migration protocol. Also handles ack's, + * spicy sends them while spicec does not */ + return red_channel_client_handle_message(rcc, size, type, msg); + } + + spice_assert(size == vheader->length + sizeof(VSCMsgHeader)); + switch (vheader->type) { + case VSC_ReaderAdd: + smartcard_channel_client_add_reader(scc, msg + sizeof(VSCMsgHeader)); + return TRUE; + break; + case VSC_ReaderRemove: + smartcard_channel_client_remove_reader(scc, vheader->reader_id); + return TRUE; + break; + case VSC_Init: + // ignore - we should never get this anyway + return TRUE; + break; + case VSC_Error: + case VSC_ATR: + case VSC_CardRemove: + case VSC_APDU: + break; // passed on to device + default: + printf("ERROR: unexpected message on smartcard channel\n"); + return TRUE; + } + + /* todo: fix */ + if (vheader->reader_id >= smartcard_get_n_readers()) { + spice_printerr("ERROR: received message for non existing reader: %d, %d, %d", vheader->reader_id, + vheader->type, vheader->length); + return FALSE; + } + spice_assert(scc->priv->write_buf->buf == msg); + smartcard_channel_client_write_to_reader(scc); + + return TRUE; +} + +int smartcard_channel_client_handle_migrate_data(RedChannelClient *rcc, + uint32_t size, + void *message) +{ + SmartCardChannelClient *scc; + SpiceMigrateDataHeader *header; + SpiceMigrateDataSmartcard *mig_data; + + scc = SMARTCARD_CHANNEL_CLIENT(rcc); + header = (SpiceMigrateDataHeader *)message; + mig_data = (SpiceMigrateDataSmartcard *)(header + 1); + if (size < sizeof(SpiceMigrateDataHeader) + sizeof(SpiceMigrateDataSmartcard)) { + spice_error("bad message size"); + return FALSE; + } + if (!migration_protocol_validate_header(header, + SPICE_MIGRATE_DATA_SMARTCARD_MAGIC, + SPICE_MIGRATE_DATA_SMARTCARD_VERSION)) { + spice_error("bad header"); + return FALSE; + } + + if (!mig_data->base.connected) { /* client wasn't attached to a smartcard */ + return TRUE; + } + + if (!scc->priv->smartcard_state) { + SpiceCharDeviceInstance *char_device = smartcard_readers_get_unattached(); + + if (!char_device) { + spice_warning("no unattached device available"); + return TRUE; + } else { + smartcard_char_device_attach_client(char_device, scc); + } + } + spice_debug("reader added %d partial read_size %u", mig_data->reader_added, mig_data->read_size); + + return smartcard_char_device_handle_migrate_data(scc->priv->smartcard_state, + mig_data); +} + +int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc) +{ + red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA); + return TRUE; +} + +void smartcard_channel_client_set_char_device(SmartCardChannelClient *scc, + RedCharDeviceSmartcard *device) +{ + if (device == scc->priv->smartcard_state) + return; + + if (scc->priv->smartcard_state) + g_object_remove_weak_pointer(G_OBJECT(scc->priv->smartcard_state), + (gpointer*)&scc->priv->smartcard_state); + + scc->priv->smartcard_state = device; + g_object_add_weak_pointer(G_OBJECT(scc->priv->smartcard_state), + (gpointer*)&scc->priv->smartcard_state); +} + +RedCharDeviceSmartcard* smartcard_channel_client_get_char_device(SmartCardChannelClient *scc) +{ + return scc->priv->smartcard_state; +} + diff --git a/server/smartcard-channel-client.h b/server/smartcard-channel-client.h new file mode 100644 index 00000000..35cb5685 --- /dev/null +++ b/server/smartcard-channel-client.h @@ -0,0 +1,113 @@ +/* + Copyright (C) 2009-2015 Red Hat, Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef SMARTCARD_CHANNEL_CLIENT_H__ +#define SMARTCARD_CHANNEL_CLIENT_H__ + +#include <glib-object.h> +#include "smartcard.h" + +G_BEGIN_DECLS + +#define TYPE_SMARTCARD_CHANNEL_CLIENT smart_card_channel_client_get_type() + +#define SMARTCARD_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_SMARTCARD_CHANNEL_CLIENT, SmartCardChannelClient)) +#define SMARTCARD_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_SMARTCARD_CHANNEL_CLIENT, SmartCardChannelClientClass)) +#define IS_SMARTCARD_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_SMARTCARD_CHANNEL_CLIENT)) +#define IS_SMARTCARD_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_SMARTCARD_CHANNEL_CLIENT)) +#define SMARTCARD_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_SMARTCARD_CHANNEL_CLIENT, SmartCardChannelClientClass)) + +typedef struct _SmartCardChannelClient SmartCardChannelClient; +typedef struct _SmartCardChannelClientClass SmartCardChannelClientClass; +typedef struct _SmartCardChannelClientPrivate SmartCardChannelClientPrivate; + +struct _SmartCardChannelClient +{ + RedChannelClient parent; + + SmartCardChannelClientPrivate *priv; +}; + +struct _SmartCardChannelClientClass +{ + RedChannelClientClass parent_class; +}; + +GType smart_card_channel_client_get_type(void) G_GNUC_CONST; + +SmartCardChannelClient* smartcard_channel_client_create(RedChannel *channel, + RedClient *client, RedsStream *stream, + int monitor_latency, + int num_common_caps, uint32_t *common_caps, + int num_caps, uint32_t *caps); + +uint8_t* smartcard_channel_client_alloc_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size); + +void smartcard_channel_client_release_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size, + uint8_t *msg); + +int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc); + +void smartcard_channel_client_on_disconnect(RedChannelClient *rcc); + +void smartcard_channel_client_send_data(RedChannelClient *rcc, + SpiceMarshaller *m, + PipeItem *item, + VSCMsgHeader *vheader); + +void smartcard_channel_client_send_error(RedChannelClient *rcc, + SpiceMarshaller *m, + PipeItem *item); + +void smartcard_channel_client_add_reader(SmartCardChannelClient *scc, + uint8_t *name); + +void smartcard_channel_client_remove_reader(SmartCardChannelClient *scc, + uint32_t reader_id); + +RedCharDeviceSmartcard* smartcard_channel_client_get_device(SmartCardChannelClient *scc); + +int smartcard_channel_client_handle_message(RedChannelClient *rcc, + uint16_t type, + uint32_t size, + uint8_t *msg); + +int smartcard_channel_client_handle_migrate_data(RedChannelClient *rcc, + uint32_t size, + void *message); + +void smartcard_channel_client_set_char_device(SmartCardChannelClient *scc, + RedCharDeviceSmartcard *device); + +RedCharDeviceSmartcard* smartcard_channel_client_get_char_device(SmartCardChannelClient *scc); + +void smartcard_channel_client_release_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size, + uint8_t *msg); + +uint8_t *smartcard_channel_client_alloc_msg_rcv_buf(RedChannelClient *rcc, + uint16_t type, + uint32_t size); + +G_END_DECLS + +#endif /* SMARTCARD_CHANNEL_CLIENT_H__ */ diff --git a/server/smartcard.c b/server/smartcard.c index 517c434e..a18ba2ae 100644 --- a/server/smartcard.c +++ b/server/smartcard.c @@ -24,8 +24,8 @@ #include "reds.h" #include "char-device.h" -#include "red-channel-client-private.h" #include "smartcard.h" +#include "smartcard-channel-client.h" #include "migration-protocol.h" /* @@ -45,17 +45,6 @@ typedef RedCharDeviceSmartcard SmartCardDeviceState; -typedef struct SmartCardChannelClient { - RedChannelClient base; - SmartCardDeviceState *smartcard_state; - - /* read_from_client/write_to_device buffer. - * The beginning of the buffer should always be VSCMsgHeader*/ - SpiceCharDeviceWriteBuffer *write_buf; - int msg_in_write_buf; /* was the client msg received into a SpiceCharDeviceWriteBuffer - * or was it explicitly malloced */ -} SmartCardChannelClient; - G_DEFINE_TYPE(RedCharDeviceSmartcard, red_char_device_smartcard, RED_TYPE_CHAR_DEVICE) #define RED_CHAR_DEVICE_SMARTCARD_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RED_TYPE_CHAR_DEVICE_SMARTCARD, RedCharDeviceSmartcardPrivate)) @@ -73,19 +62,6 @@ struct _RedCharDeviceSmartcardPrivate { int reader_added; // has reader_add been sent to the device }; -enum { - PIPE_ITEM_TYPE_ERROR = PIPE_ITEM_TYPE_CHANNEL_BASE, - PIPE_ITEM_TYPE_SMARTCARD_DATA, - PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA, -}; - -typedef struct ErrorItem { - PipeItem base; - VSCMsgHeader vheader; - VSCMsgError error; -} ErrorItem; - - typedef struct MsgItem { RedPipeItem base; @@ -104,12 +80,7 @@ static struct Readers { SpiceCharDeviceInstance* sin[SMARTCARD_MAX_READERS]; } g_smartcard_readers = {0, {NULL}}; -static SpiceCharDeviceInstance* smartcard_readers_get_unattached(void); -static SpiceCharDeviceInstance* smartcard_readers_get(uint32_t reader_id); static int smartcard_char_device_add_to_readers(RedsState *reds, SpiceCharDeviceInstance *sin); -static void smartcard_char_device_attach_client( - SpiceCharDeviceInstance *char_device, SmartCardChannelClient *scc); -static void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_buf); static MsgItem *smartcard_char_device_on_message_from_device( SmartCardDeviceState *state, VSCMsgHeader *header); @@ -169,8 +140,11 @@ static void smartcard_send_msg_to_client(RedPipeItem *msg, void *opaque) { SmartCardDeviceState *dev = opaque; - spice_assert(dev->priv->scc && dev->priv->scc->base.client == client); - smartcard_channel_client_pipe_add_push(&dev->priv->scc->base, (PipeItem *)msg); + RedClient *this_client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dev->priv->scc)); + + spice_assert(dev->priv->scc && this_client == client); + smartcard_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(dev->priv->scc), + (PipeItem *)msg); } @@ -182,10 +156,11 @@ static void smartcard_send_tokens_to_client(RedClient *client, uint32_t tokens, static void smartcard_remove_client(RedClient *client, void *opaque) { SmartCardDeviceState *dev = opaque; + RedClient *this_client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dev->priv->scc)); spice_printerr("smartcard state %p, client %p", dev, client); - spice_assert(dev->priv->scc && dev->priv->scc->base.client == client); - red_channel_client_shutdown(&dev->priv->scc->base); + spice_assert(dev->priv->scc && this_client == client); + red_channel_client_shutdown(RED_CHANNEL_CLIENT(dev->priv->scc)); } MsgItem *smartcard_char_device_on_message_from_device(SmartCardDeviceState *state, @@ -212,7 +187,8 @@ MsgItem *smartcard_char_device_on_message_from_device(SmartCardDeviceState *stat /* We patch the reader_id, since the device only knows about itself, and * we know about the sum of readers. */ sent_header->reader_id = state->priv->reader_id; - return smartcard_get_vsc_msg_item(&state->priv->scc->base, sent_header); + return smartcard_get_vsc_msg_item(RED_CHANNEL_CLIENT(state->priv->scc), + sent_header); } return NULL; } @@ -230,7 +206,7 @@ static int smartcard_char_device_add_to_readers(RedsState *reds, SpiceCharDevice return 0; } -static SpiceCharDeviceInstance *smartcard_readers_get(uint32_t reader_id) +SpiceCharDeviceInstance *smartcard_readers_get(uint32_t reader_id) { spice_assert(reader_id < g_smartcard_readers.num); return g_smartcard_readers.sin[reader_id]; @@ -238,7 +214,7 @@ static SpiceCharDeviceInstance *smartcard_readers_get(uint32_t reader_id) /* TODO: fix implementation for multiple readers. Each reader should have a separated * channel */ -static SpiceCharDeviceInstance *smartcard_readers_get_unattached(void) +SpiceCharDeviceInstance *smartcard_readers_get_unattached(void) { int i; SmartCardDeviceState* state; @@ -287,7 +263,7 @@ SpiceCharDeviceState *smartcard_device_connect(RedsState *reds, SpiceCharDeviceI return RED_CHAR_DEVICE(st); } -static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st) +void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st) { SpiceCharDeviceWriteBuffer *write_buf; VSCMsgHeader *vheader; @@ -305,44 +281,43 @@ static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st) smartcard_channel_write_to_reader(write_buf); } -static void smartcard_char_device_attach_client(SpiceCharDeviceInstance *char_device, - SmartCardChannelClient *scc) +void smartcard_char_device_attach_client(SpiceCharDeviceInstance *char_device, + SmartCardChannelClient *scc) { SmartCardDeviceState *st = spice_char_device_state_opaque_get(char_device->st); int client_added; - spice_assert(!scc->smartcard_state && !st->priv->scc); + spice_assert(!smartcard_channel_client_get_char_device(scc) && !st->priv->scc); st->priv->scc = scc; - scc->smartcard_state = st; + smartcard_channel_client_set_char_device(scc, st); client_added = spice_char_device_client_add(RED_CHAR_DEVICE(st), - scc->base.client, + red_channel_client_get_client(RED_CHANNEL_CLIENT(scc)), FALSE, /* no flow control yet */ 0, /* send queue size */ ~0, ~0, - red_channel_client_waits_for_migrate_data( - &scc->base)); + red_channel_client_waits_for_migrate_data(RED_CHANNEL_CLIENT(scc))); if (!client_added) { spice_warning("failed"); st->priv->scc = NULL; - scc->smartcard_state = NULL; - red_channel_client_disconnect(&scc->base); + smartcard_channel_client_set_char_device(scc, NULL); + red_channel_client_disconnect(RED_CHANNEL_CLIENT(scc)); } } -static void smartcard_char_device_notify_reader_remove(SmartCardDeviceState *st) +gboolean smartcard_char_device_notify_reader_remove(SmartCardDeviceState *st) { SpiceCharDeviceWriteBuffer *write_buf; VSCMsgHeader *vheader; if (!st->priv->reader_added) { spice_debug("reader add was never sent to the device"); - return; + return FALSE; } write_buf = spice_char_device_write_buffer_get(RED_CHAR_DEVICE(st), NULL, sizeof(vheader)); if (!write_buf) { spice_error("failed to allocate write buffer"); - return; + return FALSE; } st->priv->reader_added = FALSE; vheader = (VSCMsgHeader *)write_buf->buf; @@ -350,98 +325,28 @@ static void smartcard_char_device_notify_reader_remove(SmartCardDeviceState *st) vheader->reader_id = st->priv->reader_id; vheader->length = 0; smartcard_channel_write_to_reader(write_buf); -} -static void smartcard_char_device_detach_client(SmartCardChannelClient *scc) -{ - SmartCardDeviceState *st; - - if (!scc->smartcard_state) { - return; - } - st = scc->smartcard_state; - spice_assert(st->priv->scc == scc); - spice_char_device_client_remove(st->priv->chardev_st, scc->base.client); - scc->smartcard_state = NULL; - st->priv->scc = NULL; -} - -static int smartcard_channel_client_config_socket(RedChannelClient *rcc) -{ return TRUE; } -static uint8_t *smartcard_channel_alloc_msg_rcv_buf(RedChannelClient *rcc, - uint16_t type, - uint32_t size) -{ - SmartCardChannelClient *scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - - /* todo: only one reader is actually supported. When we fix the code to support - * multiple readers, we will porbably associate different devices to - * differenc channels */ - if (!scc->smartcard_state) { - scc->msg_in_write_buf = FALSE; - return spice_malloc(size); - } else { - SmartCardDeviceState *st; - - spice_assert(g_smartcard_readers.num == 1); - st = scc->smartcard_state; - spice_assert(st->priv->scc || scc->smartcard_state); - spice_assert(!scc->write_buf); - scc->write_buf = spice_char_device_write_buffer_get(RED_CHAR_DEVICE(st), rcc->client, size); - - if (!scc->write_buf) { - spice_error("failed to allocate write buffer"); - return NULL; - } - scc->msg_in_write_buf = TRUE; - return scc->write_buf->buf; - } -} - -static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc, - uint16_t type, - uint32_t size, - uint8_t *msg) +void smartcard_char_device_detach_client(RedCharDeviceSmartcard *smartcard, + SmartCardChannelClient *scc) { - SmartCardChannelClient *scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - - /* todo: only one reader is actually supported. When we fix the code to support - * multiple readers, we will porbably associate different devices to - * differenc channels */ - - if (!scc->msg_in_write_buf) { - spice_assert(!scc->write_buf); - free(msg); - } else { - if (scc->write_buf) { /* msg hasn't been pushed to the guest */ - spice_assert(scc->write_buf->buf == msg); - spice_char_device_write_buffer_release(RED_CHAR_DEVICE(scc->smartcard_state), scc->write_buf); - scc->write_buf = NULL; - } - } + spice_assert(smartcard->priv->scc == scc); + spice_char_device_client_remove(smartcard->priv->chardev_st, + red_channel_client_get_client(RED_CHANNEL_CLIENT(scc))); + smartcard_channel_client_set_char_device(scc, NULL); + smartcard->priv->scc = NULL; } -static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *m, - PipeItem *item, VSCMsgHeader *vheader) +static int smartcard_channel_client_config_socket(RedChannelClient *rcc) { - spice_assert(rcc); - spice_assert(vheader); - red_channel_client_init_send_data(rcc, SPICE_MSG_SMARTCARD_DATA, item); - spice_marshaller_add_ref(m, (uint8_t*)vheader, sizeof(VSCMsgHeader)); - if (vheader->length > 0) { - spice_marshaller_add_ref(m, (uint8_t*)(vheader+1), vheader->length); - } + return TRUE; } -static void smartcard_channel_send_error( - RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item) +SmartCardChannelClient* smartcard_char_device_get_client(RedCharDeviceSmartcard *smartcard) { - ErrorItem* error_item = (ErrorItem*)item; - - smartcard_channel_send_data(rcc, m, item, &error_item->vheader); + return smartcard->priv->scc; } static void smartcard_channel_send_msg(RedChannelClient *rcc, @@ -449,7 +354,7 @@ static void smartcard_channel_send_msg(RedChannelClient *rcc, { MsgItem* msg_item = (MsgItem*)item; - smartcard_channel_send_data(rcc, m, item, msg_item->vheader); + smartcard_channel_client_send_data(rcc, m, item, msg_item->vheader); } static void smartcard_channel_send_migrate_data(RedChannelClient *rcc, @@ -459,8 +364,8 @@ static void smartcard_channel_send_migrate_data(RedChannelClient *rcc, SmartCardDeviceState *state; SpiceMarshaller *m2; - scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - state = scc->smartcard_state; + scc = SMARTCARD_CHANNEL_CLIENT(rcc); + state = smartcard_channel_client_get_char_device(scc); red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item); spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SMARTCARD_MAGIC); spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SMARTCARD_VERSION); @@ -487,7 +392,7 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem *item) switch (item->type) { case PIPE_ITEM_TYPE_ERROR: - smartcard_channel_send_error(rcc, m, item); + smartcard_channel_client_send_error(rcc, m, item); break; case PIPE_ITEM_TYPE_SMARTCARD_DATA: smartcard_channel_send_msg(rcc, m, item); @@ -513,18 +418,6 @@ static void smartcard_channel_release_pipe_item(RedChannelClient *rcc, } } -static void smartcard_channel_on_disconnect(RedChannelClient *rcc) -{ - SmartCardChannelClient *scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - - if (scc->smartcard_state) { - SmartCardDeviceState *st = scc->smartcard_state; - - smartcard_char_device_detach_client(scc); - smartcard_char_device_notify_reader_remove(st); - } -} - /* this is called from both device input and client input. since the device is * a usb device, the context is still the main thread (kvm_main_loop, timers) * so no mutex is required. */ @@ -533,20 +426,6 @@ static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, PipeIt red_channel_client_pipe_add_push(rcc, item); } -static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCErrorCode error) -{ - ErrorItem *error_item = spice_new0(ErrorItem, 1); - - pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR); - - error_item->base.type = 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); - error_item->error.code = error; - smartcard_channel_client_pipe_add_push(rcc, &error_item->base); -} - static void smartcard_free_vsc_msg_item(MsgItem *item) { free(item->vheader); @@ -563,47 +442,7 @@ static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader * return msg_item; } -static void smartcard_remove_reader(SmartCardChannelClient *scc, uint32_t reader_id) -{ - SpiceCharDeviceInstance *char_device = smartcard_readers_get(reader_id); - SmartCardDeviceState *state; - - if (char_device == NULL) { - smartcard_push_error(&scc->base, reader_id, - VSC_GENERAL_ERROR); - return; - } - - state = spice_char_device_state_opaque_get(char_device->st); - if (state->priv->reader_added == FALSE) { - smartcard_push_error(&scc->base, reader_id, - VSC_GENERAL_ERROR); - return; - } - spice_assert(scc->smartcard_state == state); - smartcard_char_device_notify_reader_remove(state); -} - -static void smartcard_add_reader(SmartCardChannelClient *scc, uint8_t *name) -{ - if (!scc->smartcard_state) { /* we already tried to attach a reader to the client - when it connected */ - SpiceCharDeviceInstance *char_device = smartcard_readers_get_unattached(); - - if (!char_device) { - smartcard_push_error(&scc->base, VSCARD_UNDEFINED_READER_ID, - VSC_CANNOT_ADD_MORE_READERS); - return; - } - smartcard_char_device_attach_client(char_device, scc); - } - smartcard_char_device_notify_reader_add(scc->smartcard_state); - // The device sends a VSC_Error message, we will let it through, no - // need to send our own. We already set the correct reader_id, from - // our SmartCardDeviceState. -} - -static void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_buf) +void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_buf) { SpiceCharDeviceInstance *sin; SmartCardDeviceState *st; @@ -616,7 +455,8 @@ static void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_ spice_assert(vheader->reader_id <= g_smartcard_readers.num); sin = g_smartcard_readers.sin[vheader->reader_id]; st = (SmartCardDeviceState *)spice_char_device_state_opaque_get(sin->st); - spice_assert(!st->priv->scc || st == st->priv->scc->smartcard_state); + spice_assert(!st->priv->scc || + st == smartcard_channel_client_get_device(st->priv->scc)); /* protocol requires messages to be in network endianess */ vheader->type = htonl(vheader->type); vheader->length = htonl(vheader->length); @@ -625,15 +465,6 @@ static void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_ /* pushing the buffer to the write queue; It will be released * when it will be fully consumed by the device */ spice_char_device_write_buffer_add(sin->st, write_buf); - if (st->priv->scc && write_buf == st->priv->scc->write_buf) { - st->priv->scc->write_buf = NULL; - } -} - -static int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc) -{ - red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA); - return TRUE; } static void smartcard_device_state_restore_partial_read(SmartCardDeviceState *state, @@ -653,96 +484,13 @@ static void smartcard_device_state_restore_partial_read(SmartCardDeviceState *st state->priv->buf_pos = state->priv->buf + mig_data->read_size; } -static int smartcard_channel_client_handle_migrate_data(RedChannelClient *rcc, - uint32_t size, void *message) +int smartcard_char_device_handle_migrate_data(RedCharDeviceSmartcard *smartcard, + SpiceMigrateDataSmartcard *mig_data) { - SmartCardChannelClient *scc; - SpiceMigrateDataHeader *header; - SpiceMigrateDataSmartcard *mig_data; - - scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - header = (SpiceMigrateDataHeader *)message; - mig_data = (SpiceMigrateDataSmartcard *)(header + 1); - if (size < sizeof(SpiceMigrateDataHeader) + sizeof(SpiceMigrateDataSmartcard)) { - spice_error("bad message size"); - return FALSE; - } - if (!migration_protocol_validate_header(header, - SPICE_MIGRATE_DATA_SMARTCARD_MAGIC, - SPICE_MIGRATE_DATA_SMARTCARD_VERSION)) { - spice_error("bad header"); - return FALSE; - } - - if (!mig_data->base.connected) { /* client wasn't attached to a smartcard */ - return TRUE; - } + smartcard->priv->reader_added = mig_data->reader_added; - if (!scc->smartcard_state) { - SpiceCharDeviceInstance *char_device = smartcard_readers_get_unattached(); - - if (!char_device) { - spice_warning("no unattached device available"); - return TRUE; - } else { - smartcard_char_device_attach_client(char_device, scc); - } - } - spice_debug("reader added %d partial read_size %u", mig_data->reader_added, mig_data->read_size); - scc->smartcard_state->priv->reader_added = mig_data->reader_added; - - smartcard_device_state_restore_partial_read(scc->smartcard_state, mig_data); - return spice_char_device_state_restore(RED_CHAR_DEVICE(scc->smartcard_state), &mig_data->base); -} - -static int smartcard_channel_handle_message(RedChannelClient *rcc, - uint16_t type, - uint32_t size, - uint8_t *msg) -{ - VSCMsgHeader* vheader = (VSCMsgHeader*)msg; - SmartCardChannelClient *scc = SPICE_CONTAINEROF(rcc, SmartCardChannelClient, base); - - if (type != SPICE_MSGC_SMARTCARD_DATA) { - /* Handles seamless migration protocol. Also handles ack's, - * spicy sends them while spicec does not */ - return red_channel_client_handle_message(rcc, size, type, msg); - } - - spice_assert(size == vheader->length + sizeof(VSCMsgHeader)); - switch (vheader->type) { - case VSC_ReaderAdd: - smartcard_add_reader(scc, msg + sizeof(VSCMsgHeader)); - return TRUE; - break; - case VSC_ReaderRemove: - smartcard_remove_reader(scc, vheader->reader_id); - return TRUE; - break; - case VSC_Init: - // ignore - we should never get this anyway - return TRUE; - break; - case VSC_Error: - case VSC_ATR: - case VSC_CardRemove: - case VSC_APDU: - break; // passed on to device - default: - printf("ERROR: unexpected message on smartcard channel\n"); - return TRUE; - } - - /* todo: fix */ - if (vheader->reader_id >= g_smartcard_readers.num) { - spice_printerr("ERROR: received message for non existing reader: %d, %d, %d", vheader->reader_id, - vheader->type, vheader->length); - return FALSE; - } - spice_assert(scc->write_buf->buf == msg); - smartcard_channel_write_to_reader(scc->write_buf); - - return TRUE; + smartcard_device_state_restore_partial_read(smartcard, mig_data); + return spice_char_device_state_restore(RED_CHAR_DEVICE(smartcard), &mig_data->base); } static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item) @@ -759,18 +507,17 @@ static void smartcard_connect_client(RedChannel *channel, RedClient *client, SmartCardChannelClient *scc; - scc = (SmartCardChannelClient *)red_channel_client_create(sizeof(SmartCardChannelClient), - channel, - client, - stream, - FALSE, - num_common_caps, common_caps, - num_caps, caps); + scc = smartcard_channel_client_create(channel, + client, + stream, + FALSE, + num_common_caps, common_caps, + num_caps, caps); if (!scc) { return; } - red_channel_client_ack_zero_messages_window(&scc->base); + red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(scc)); if (char_device) { smartcard_char_device_attach_client(char_device, scc); @@ -790,12 +537,12 @@ static void smartcard_init(RedsState *reds) spice_assert(!g_smartcard_channel); channel_cbs.config_socket = smartcard_channel_client_config_socket; - channel_cbs.on_disconnect = smartcard_channel_on_disconnect; + channel_cbs.on_disconnect = smartcard_channel_client_on_disconnect; channel_cbs.send_item = smartcard_channel_send_item; channel_cbs.hold_item = smartcard_channel_hold_pipe_item; channel_cbs.release_item = smartcard_channel_release_pipe_item; - channel_cbs.alloc_recv_buf = smartcard_channel_alloc_msg_rcv_buf; - channel_cbs.release_recv_buf = smartcard_channel_release_msg_rcv_buf; + channel_cbs.alloc_recv_buf = smartcard_channel_client_alloc_msg_rcv_buf; + channel_cbs.release_recv_buf = smartcard_channel_client_release_msg_rcv_buf; channel_cbs.handle_migrate_flush_mark = smartcard_channel_client_handle_migrate_flush_mark; channel_cbs.handle_migrate_data = smartcard_channel_client_handle_migrate_data; @@ -803,7 +550,7 @@ static void smartcard_init(RedsState *reds) reds, reds_get_core_interface(reds), SPICE_CHANNEL_SMARTCARD, 0, FALSE /* handle_acks */, - smartcard_channel_handle_message, + smartcard_channel_client_handle_message, &channel_cbs, migration_flags); @@ -824,9 +571,6 @@ red_char_device_smartcard_finalize(GObject *object) RedCharDeviceSmartcard *self = RED_CHAR_DEVICE_SMARTCARD(object); free(self->priv->buf); - if (self->priv->scc) { - self->priv->scc->smartcard_state = NULL; - } G_OBJECT_CLASS(red_char_device_smartcard_parent_class)->finalize(object); } @@ -857,3 +601,8 @@ red_char_device_smartcard_init(RedCharDeviceSmartcard *self) self->priv->buf = spice_malloc(self->priv->buf_size); self->priv->buf_pos = self->priv->buf; } + +uint32_t smartcard_get_n_readers(void) +{ + return g_smartcard_readers.num; +} diff --git a/server/smartcard.h b/server/smartcard.h index 8d1ca67b..c10fa9f3 100644 --- a/server/smartcard.h +++ b/server/smartcard.h @@ -19,6 +19,7 @@ #define __SMART_CARD_H__ #include <glib-object.h> +#include "char-device.h" // Maximal length of APDU #define APDUBufSize 270 @@ -34,6 +35,7 @@ typedef struct _RedCharDeviceSmartcard RedCharDeviceSmartcard; typedef struct _RedCharDeviceSmartcardClass RedCharDeviceSmartcardClass; typedef struct _RedCharDeviceSmartcardPrivate RedCharDeviceSmartcardPrivate; +typedef struct _SmartCardChannelClient SmartCardChannelClient; struct _RedCharDeviceSmartcard { @@ -55,5 +57,24 @@ GType red_char_device_smartcard_get_type(void) G_GNUC_CONST; */ SpiceCharDeviceState *smartcard_device_connect(RedsState *reds, SpiceCharDeviceInstance *char_device); void smartcard_device_disconnect(SpiceCharDeviceInstance *char_device); +void smartcard_channel_write_to_reader(SpiceCharDeviceWriteBuffer *write_buf); +SpiceCharDeviceInstance* smartcard_readers_get(uint32_t reader_id); +SpiceCharDeviceInstance *smartcard_readers_get_unattached(void); +uint32_t smartcard_get_n_readers(void); +void smartcard_char_device_notify_reader_add(RedCharDeviceSmartcard *smartcard); +void smartcard_char_device_attach_client(SpiceCharDeviceInstance *smartcard, + SmartCardChannelClient *scc); +gboolean smartcard_char_device_notify_reader_remove(RedCharDeviceSmartcard *smartcard); +void smartcard_char_device_detach_client(RedCharDeviceSmartcard *smartcard, + SmartCardChannelClient *scc); +SmartCardChannelClient* smartcard_char_device_get_client(RedCharDeviceSmartcard *smartcard); +int smartcard_char_device_handle_migrate_data(RedCharDeviceSmartcard *smartcard, + SpiceMigrateDataSmartcard *mig_data); + +enum { + PIPE_ITEM_TYPE_ERROR = PIPE_ITEM_TYPE_CHANNEL_BASE, + PIPE_ITEM_TYPE_SMARTCARD_DATA, + PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA, +}; #endif // __SMART_CARD_H__ diff --git a/server/sound.c b/server/sound.c index 396a0075..2458093b 100644 --- a/server/sound.c +++ b/server/sound.c @@ -32,10 +32,13 @@ #include "spice.h" #include "common.h" +#include "dummy-channel-client.h" #include "main-channel.h" #include "main-channel-client.h" #include "reds.h" #include "red-dispatcher.h" +/* FIXME: for now, allow the sound channel to access private RedChannelClient + * data... */ #include "red-channel-client-private.h" #include "sound.h" #include "demarshallers.h" @@ -521,7 +524,7 @@ static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb) return FALSE; } - header = &channel->channel_client->send_data.header; + header = &channel->channel_client->priv->send_data.header; spice_marshaller_reset(channel->send_data.marshaller); header->data = spice_marshaller_reserve_space(channel->send_data.marshaller, header->header_size); @@ -531,7 +534,7 @@ static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb) header->set_msg_size(header, 0); header->set_msg_type(header, verb); channel->send_data.serial++; - if (!channel->channel_client->is_mini_header) { + if (!channel->channel_client->priv->is_mini_header) { header->set_msg_serial(header, channel->send_data.serial); header->set_msg_sub_list(header, 0); } @@ -541,7 +544,7 @@ static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb) static int snd_begin_send_message(SndChannel *channel) { - SpiceDataHeaderOpaque *header = &channel->channel_client->send_data.header; + SpiceDataHeaderOpaque *header = &channel->channel_client->priv->send_data.header; spice_marshaller_flush(channel->send_data.marshaller); channel->send_data.size = spice_marshaller_get_total_size(channel->send_data.marshaller); @@ -973,11 +976,9 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i channel->on_message_done = on_message_done; channel->cleanup = cleanup; - channel->channel_client = red_channel_client_create_dummy(sizeof(RedChannelClient), - worker->base_channel, - client, - num_common_caps, common_caps, - num_caps, caps); + channel->channel_client = + dummy_channel_client_create(worker->base_channel, client, + num_common_caps, common_caps, num_caps, caps); if (!channel->channel_client) { goto error2; } @@ -994,12 +995,13 @@ error1: static void snd_disconnect_channel_client(RedChannelClient *rcc) { SndWorker *worker; + RedChannel *channel = red_channel_client_get_channel(rcc); - spice_assert(rcc->channel); - spice_assert(rcc->channel->data); - worker = (SndWorker *)rcc->channel->data; + spice_assert(channel); + spice_assert(channel->data); + worker = (SndWorker *)channel->data; - spice_debug("channel-type=%d", rcc->channel->type); + spice_debug("channel-type=%d", channel->type); if (worker->connection) { spice_assert(worker->connection->channel_client == rcc); snd_disconnect_channel(worker->connection); @@ -1144,7 +1146,7 @@ void snd_set_playback_latency(RedClient *client, uint32_t latency) for (; now; now = now->next) { if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection && - now->connection->channel_client->client == client) { + red_channel_client_get_client(now->connection->channel_client) == client) { if (red_channel_client_test_remote_cap(now->connection->channel_client, SPICE_PLAYBACK_CAP_LATENCY)) { @@ -1263,11 +1265,12 @@ static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsSt static void snd_record_migrate_channel_client(RedChannelClient *rcc) { SndWorker *worker; + RedChannel *channel = red_channel_client_get_channel(rcc); spice_debug(NULL); - spice_assert(rcc->channel); - spice_assert(rcc->channel->data); - worker = (SndWorker *)rcc->channel->data; + spice_assert(channel); + spice_assert(channel->data); + worker = (SndWorker *)channel->data; if (worker->connection) { spice_assert(worker->connection->channel_client == rcc); @@ -1492,10 +1495,11 @@ static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStre static void snd_playback_migrate_channel_client(RedChannelClient *rcc) { SndWorker *worker; + RedChannel *channel = red_channel_client_get_channel(rcc); - spice_assert(rcc->channel); - spice_assert(rcc->channel->data); - worker = (SndWorker *)rcc->channel->data; + spice_assert(channel); + spice_assert(channel->data); + worker = (SndWorker *)channel->data; spice_debug(NULL); if (worker->connection) { diff --git a/server/spicevmc.c b/server/spicevmc.c index a4bdcc4e..16e72772 100644 --- a/server/spicevmc.c +++ b/server/spicevmc.c @@ -487,10 +487,8 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client, return; } - rcc = red_channel_client_create(sizeof(RedChannelClient), channel, client, stream, - FALSE, - num_common_caps, common_caps, - num_caps, caps); + rcc = red_channel_client_create(channel, client, stream, FALSE, + num_common_caps, common_caps, num_caps, caps); if (!rcc) { return; } diff --git a/server/stream.c b/server/stream.c index b656c457..e0c53a86 100644 --- a/server/stream.c +++ b/server/stream.c @@ -339,7 +339,7 @@ static void before_reattach_stream(DisplayChannel *display, agent = dcc_get_stream_agent(dcc, index); if (!dcc_use_mjpeg_encoder_rate_control(dcc) && - !common_worker_channel_client_is_low_bandwidth((CommonWorkerChannelClient*)dcc)) { + !common_worker_channel_client_is_low_bandwidth(COMMON_WORKER_CHANNEL_CLIENT(dcc))) { continue; } @@ -647,7 +647,7 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient *dcc, Stream *stream) * If the network info is not initialized due to another reason, * the low_bandwidth flag is FALSE. */ - bit_rate = common_worker_channel_client_is_low_bandwidth((CommonWorkerChannelClient*)dcc) ? + bit_rate = common_worker_channel_client_is_low_bandwidth(COMMON_WORKER_CHANNEL_CLIENT(dcc)) ? RED_STREAM_DEFAULT_LOW_START_BIT_RATE : RED_STREAM_DEFAULT_HIGH_START_BIT_RATE; } diff --git a/server/tests/test_display_base.c b/server/tests/test_display_base.c index 5e3a2b61..4c858235 100644 --- a/server/tests/test_display_base.c +++ b/server/tests/test_display_base.c @@ -16,6 +16,7 @@ #include "test_display_base.h" #include "red-channel.h" #include "test_util.h" +#include "common/mem.h" #ifndef PATH_MAX #define PATH_MAX 4096 |