[Spice-commits] 12 commits - server/cache-item.h server/cache-item.tmpl.c server/char-device.c server/char-device.h server/cursor-channel.c server/dcc.c server/dcc.h server/dcc-send.c server/display-channel.c server/display-channel.h server/inputs-channel.c server/main-channel.c server/red-channel.c server/red-channel.h server/red-pipe-item.c server/red-pipe-item.h server/reds.c server/reds.h server/reds-private.h server/red-worker.h server/smartcard.c server/sound.c server/spice-migration.h server/spice-server.h server/spicevmc.c server/stream.c server/stream.h
Jonathon Jongsma
jjongsma at kemper.freedesktop.org
Wed Apr 27 16:45:29 UTC 2016
server/cache-item.h | 8
server/cache-item.tmpl.c | 18 -
server/char-device.c | 86 ++-------
server/char-device.h | 6
server/cursor-channel.c | 91 ++++-----
server/dcc-send.c | 177 +++++++++---------
server/dcc.c | 243 ++++++++++++-------------
server/dcc.h | 46 ++--
server/display-channel.c | 51 ++---
server/display-channel.h | 59 +++---
server/inputs-channel.c | 74 +++----
server/main-channel.c | 295 +++++++++++++++----------------
server/red-channel.c | 87 ++++-----
server/red-channel.h | 40 ++--
server/red-pipe-item.c | 14 -
server/red-pipe-item.h | 14 -
server/red-worker.h | 18 -
server/reds-private.h | 34 ---
server/reds.c | 443 ++++++++++++++++++++++++++---------------------
server/reds.h | 8
server/smartcard.c | 91 ++++-----
server/sound.c | 13 -
server/spice-migration.h | 6
server/spice-server.h | 12 -
server/spicevmc.c | 91 ++++-----
server/stream.c | 40 ++--
server/stream.h | 18 -
27 files changed, 1050 insertions(+), 1033 deletions(-)
New commits:
commit fb1ccd0f0dc73f4f63446d3ee1a12f3b1ce5be7d
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 16:19:14 2015 +0100
audio: Remove global 'playback_compression' variable
This variable belongs to SpiceServerConfig rather than being a static
global variable hidden in sound.c
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/reds.c b/server/reds.c
index 19baf2b..08f827c 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -177,6 +177,7 @@ struct RedServerConfig {
gboolean ticketing_enabled;
uint32_t streaming_video;
SpiceImageCompression image_compression;
+ uint32_t playback_compression;
spice_wan_compression_t jpeg_state;
spice_wan_compression_t zlib_glz_state;
@@ -677,6 +678,11 @@ static void reds_mig_disconnect(RedsState *reds)
}
}
+int reds_config_get_playback_compression(RedsState *reds)
+{
+ return reds->config->playback_compression;
+}
+
int reds_get_mouse_mode(RedsState *reds)
{
return reds->mouse_mode;
@@ -3527,6 +3533,7 @@ SPICE_GNUC_VISIBLE SpiceServer *spice_server_new(void)
reds->config->ticketing_enabled = TRUE; /* ticketing enabled by default */
reds->config->streaming_video = SPICE_STREAM_VIDEO_FILTER;
reds->config->image_compression = SPICE_IMAGE_COMPRESSION_AUTO_GLZ;
+ reds->config->playback_compression = TRUE;
reds->config->jpeg_state = SPICE_WAN_COMPRESSION_AUTO;
reds->config->zlib_glz_state = SPICE_WAN_COMPRESSION_AUTO;
reds->config->agent_mouse = TRUE;
@@ -3886,6 +3893,7 @@ uint32_t reds_get_streaming_video(const RedsState *reds)
SPICE_GNUC_VISIBLE int spice_server_set_playback_compression(SpiceServer *reds, int enable)
{
+ reds->config->playback_compression = !!enable;
snd_set_playback_compression(enable);
return 0;
}
diff --git a/server/reds.h b/server/reds.h
index 9de506f..fbf7372 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -60,6 +60,8 @@ void reds_unregister_channel(RedsState *reds, RedChannel *channel);
int reds_get_mouse_mode(RedsState *reds); // used by inputs_channel
gboolean reds_config_get_agent_mouse(const RedsState *reds); // used by inputs_channel
int reds_has_vdagent(RedsState *reds); // used by inputs channel
+int reds_config_get_playback_compression(RedsState *reds); // used by playback channel
+
void reds_handle_agent_mouse_event(RedsState *reds, const VDAgentMouseState *mouse_state); // used by inputs_channel
GArray* reds_get_renderers(RedsState *reds);
diff --git a/server/sound.c b/server/sound.c
index 46f2cb1..aae841c 100644
--- a/server/sound.c
+++ b/server/sound.c
@@ -183,7 +183,6 @@ typedef struct RecordChannel {
/* A list of all Spice{Playback,Record}State objects */
static SndWorker *workers;
-static uint32_t playback_compression = TRUE;
static void snd_receive(SndChannel *channel);
@@ -1157,7 +1156,8 @@ void snd_set_playback_latency(RedClient *client, uint32_t latency)
}
}
-static int snd_desired_audio_mode(int frequency, int client_can_celt, int client_can_opus)
+static int snd_desired_audio_mode(int playback_compression, int frequency,
+ int client_can_celt, int client_can_opus)
{
if (! playback_compression)
return SPICE_AUDIO_DATA_MODE_RAW;
@@ -1236,7 +1236,9 @@ static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsSt
SPICE_PLAYBACK_CAP_CELT_0_5_1);
int client_can_opus = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
SPICE_PLAYBACK_CAP_OPUS);
- int desired_mode = snd_desired_audio_mode(st->frequency, client_can_celt, client_can_opus);
+ int playback_compression = reds_config_get_playback_compression(channel->reds);
+ int desired_mode = snd_desired_audio_mode(playback_compression, st->frequency,
+ client_can_celt, client_can_opus);
playback_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
if (snd_codec_create(&playback_channel->codec, desired_mode, st->frequency, SND_CODEC_ENCODE) == SND_CODEC_OK) {
@@ -1617,8 +1619,6 @@ void snd_set_playback_compression(int on)
{
SndWorker *now = workers;
- playback_compression = !!on;
-
for (; now; now = now->next) {
if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection) {
PlaybackChannel* playback = (PlaybackChannel*)now->connection;
@@ -1627,7 +1627,8 @@ void snd_set_playback_compression(int on)
SPICE_PLAYBACK_CAP_CELT_0_5_1);
int client_can_opus = red_channel_client_test_remote_cap(playback->base.channel_client,
SPICE_PLAYBACK_CAP_OPUS);
- int desired_mode = snd_desired_audio_mode(st->frequency, client_can_opus, client_can_celt);
+ int desired_mode = snd_desired_audio_mode(on, st->frequency,
+ client_can_opus, client_can_celt);
if (playback->mode != desired_mode) {
playback->mode = desired_mode;
snd_set_command(now->connection, SND_PLAYBACK_MODE_MASK);
commit 8551280d436a6e2ee2bc3dd3674e609b855b7407
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 16:20:11 2015 +0100
Remove dead code in reds_fill_channels()
channels_info->num_of_channels is assigned, its value is not used, and
then it's assigned a different value. The first assignment can be
removed.
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/reds.c b/server/reds.c
index d83b8de..19baf2b 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -1004,7 +1004,6 @@ static void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info)
RingItem *now;
int used_channels = 0;
- channels_info->num_of_channels = reds->num_of_channels;
RING_FOREACH(now, &reds->channels) {
RedChannel *channel = SPICE_CONTAINEROF(now, RedChannel, link);
if (reds->num_clients > 1 &&
commit 8e5bacd8b1d201b4e652fd6874819737cbd3cf0e
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 16:02:36 2015 +0100
Improve Reds/RedMainChannel interface
Instead of exporting 2 methods to get number of channels, and to fill
channel information, and use that from the main channel code, it's
better to do everything in one go in reds.c, and call that single method
from the main channel code.
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/main-channel.c b/server/main-channel.c
index 33f8eed..7d55de7 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -340,9 +340,7 @@ static void main_channel_marshall_channels(RedChannelClient *rcc,
SpiceMsgChannels* channels_info;
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_CHANNELS_LIST, item);
- channels_info = (SpiceMsgChannels *)spice_malloc(sizeof(SpiceMsgChannels)
- + reds_get_n_channels(rcc->channel->reds) * sizeof(SpiceChannelId));
- reds_fill_channels(rcc->channel->reds, channels_info);
+ channels_info = reds_msg_channels_new(rcc->channel->reds);
spice_marshall_msg_main_channels_list(m, channels_info);
free(channels_info);
}
diff --git a/server/reds.c b/server/reds.c
index fa30a33..d83b8de 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -977,12 +977,6 @@ void reds_handle_agent_mouse_event(RedsState *reds, const VDAgentMouseState *mou
red_char_device_write_buffer_add(RED_CHAR_DEVICE(reds->agent_dev), char_dev_buf);
}
-int reds_get_n_channels(RedsState *reds)
-{
- return reds ? reds->num_of_channels : 0;
-}
-
-
static int reds_get_n_clients(RedsState *reds)
{
return reds ? reds->num_clients : 0;
@@ -1005,7 +999,7 @@ static int channel_supports_multiple_clients(RedChannel *channel)
return FALSE;
}
-void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info)
+static void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info)
{
RingItem *now;
int used_channels = 0;
@@ -1028,6 +1022,20 @@ void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info)
}
}
+SpiceMsgChannels *reds_msg_channels_new(RedsState *reds)
+{
+ SpiceMsgChannels* channels_info;
+
+ spice_assert(reds != NULL);
+
+ channels_info = (SpiceMsgChannels *)spice_malloc(sizeof(SpiceMsgChannels)
+ + reds->num_of_channels * sizeof(SpiceChannelId));
+
+ reds_fill_channels(reds, channels_info);
+
+ return channels_info;
+}
+
void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens)
{
RedCharDevice *dev_state = RED_CHAR_DEVICE(reds->agent_dev);
diff --git a/server/reds.h b/server/reds.h
index ef1f2a8..9de506f 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -79,8 +79,7 @@ void reds_client_disconnect(RedsState *reds, RedClient *client);
// Temporary (?) for splitting main channel
typedef struct MainMigrateData MainMigrateData;
void reds_marshall_migrate_data(RedsState *reds, SpiceMarshaller *m);
-void reds_fill_channels(RedsState *reds, SpiceMsgChannels *channels_info);
-int reds_get_n_channels(RedsState *reds);
+SpiceMsgChannels *reds_msg_channels_new(RedsState *reds);
/* callbacks from main channel messages */
commit b0cc5bfcbd6f4314f09b76d59db7d0c789ac4a06
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 15:43:36 2015 +0100
Add _config_ to SpiceServerConfig accessors
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index d1af9cf..da26cf6 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -363,8 +363,8 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT) {
break;
}
- spice_assert((reds_get_agent_mouse(reds) && reds_has_vdagent(reds)) || tablet);
- if (!reds_get_agent_mouse(reds) || !reds_has_vdagent(reds)) {
+ spice_assert((reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds)) || tablet);
+ if (!reds_config_get_agent_mouse(reds) || !reds_has_vdagent(reds)) {
SpiceTabletInterface *sif;
sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
sif->position(tablet, pos->x, pos->y, RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
@@ -387,7 +387,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
dz = 1;
}
if (reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_CLIENT) {
- if (reds_get_agent_mouse(reds) && reds_has_vdagent(reds)) {
+ if (reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds)) {
inputs_channel->mouse_state.buttons =
RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
(dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
@@ -409,7 +409,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
case SPICE_MSGC_INPUTS_MOUSE_RELEASE: {
SpiceMsgcMouseRelease *mouse_release = message;
if (reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_CLIENT) {
- if (reds_get_agent_mouse(reds) && reds_has_vdagent(reds)) {
+ if (reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds)) {
inputs_channel->mouse_state.buttons =
RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
reds_handle_agent_mouse_event(reds, &inputs_channel->mouse_state);
diff --git a/server/reds.c b/server/reds.c
index 1d98218..fa30a33 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -699,7 +699,7 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode)
main_channel_push_mouse_mode(reds->main_channel, reds->mouse_mode, reds->is_client_mouse_allowed);
}
-gboolean reds_get_agent_mouse(const RedsState *reds)
+gboolean reds_config_get_agent_mouse(const RedsState *reds)
{
return reds->config->agent_mouse;
}
@@ -2927,7 +2927,7 @@ static inline void on_activating_ticketing(RedsState *reds)
}
}
-static void reds_set_image_compression(RedsState *reds, SpiceImageCompression val)
+static void reds_config_set_image_compression(RedsState *reds, SpiceImageCompression val)
{
if (val == reds->config->image_compression) {
return;
@@ -3760,11 +3760,11 @@ SPICE_GNUC_VISIBLE int spice_server_set_image_compression(SpiceServer *s,
if (comp == SPICE_IMAGE_COMPRESSION_LZ4) {
spice_warning("LZ4 compression not supported, falling back to auto GLZ");
comp = SPICE_IMAGE_COMPRESSION_AUTO_GLZ;
- reds_set_image_compression(s, comp);
+ reds_config_set_image_compression(s, comp);
return -1;
}
#endif
- reds_set_image_compression(s, comp);
+ reds_config_set_image_compression(s, comp);
return 0;
}
diff --git a/server/reds.h b/server/reds.h
index 5b33432..ef1f2a8 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -58,7 +58,7 @@ void reds_set_client_mouse_allowed(RedsState *reds,
void reds_register_channel(RedsState *reds, RedChannel *channel);
void reds_unregister_channel(RedsState *reds, RedChannel *channel);
int reds_get_mouse_mode(RedsState *reds); // used by inputs_channel
-gboolean reds_get_agent_mouse(const RedsState *reds); // used by inputs_channel
+gboolean reds_config_get_agent_mouse(const RedsState *reds); // used by inputs_channel
int reds_has_vdagent(RedsState *reds); // used by inputs channel
void reds_handle_agent_mouse_event(RedsState *reds, const VDAgentMouseState *mouse_state); // used by inputs_channel
commit b41220b1441b8adea6db9a98e9da1b43a8f426bb
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 15:28:22 2015 +0100
Mark unused public API methods/code as deprecated
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/spice-migration.h b/server/spice-migration.h
index 51c6444..944e133 100644
--- a/server/spice-migration.h
+++ b/server/spice-migration.h
@@ -46,8 +46,8 @@ struct SpiceMigrateInstance {
/* spice switch-host client migration */
int spice_server_migrate_info(SpiceServer *s, const char* dest,
int port, int secure_port,
- const char* cert_subject);
-int spice_server_migrate_switch(SpiceServer *s);
+ const char* cert_subject) G_GNUC_DEPRECATED;
+int spice_server_migrate_switch(SpiceServer *s) G_GNUC_DEPRECATED;
/* spice (semi-)seamless client migration */
int spice_server_migrate_connect(SpiceServer *s, const char* dest,
@@ -56,6 +56,6 @@ int spice_server_migrate_connect(SpiceServer *s, const char* dest,
int spice_server_migrate_start(SpiceServer *s);
int spice_server_migrate_end(SpiceServer *s, int completed);
-void spice_server_set_seamless_migration(SpiceServer *s, int enable);
+void spice_server_set_seamless_migration(SpiceServer *s, int enable) G_GNUC_DEPRECATED;
#endif /* SPICE_MIGRATION_H_ */
diff --git a/server/spice-server.h b/server/spice-server.h
index c2ff61d..d309f18 100644
--- a/server/spice-server.h
+++ b/server/spice-server.h
@@ -22,6 +22,8 @@
#error "Only spice.h can be included directly."
#endif
+#include <glib.h>
+
#include "spice-core.h"
/* Don't use features incompatible with a specific spice
@@ -48,7 +50,7 @@ int spice_server_set_compat_version(SpiceServer *s,
spice_compat_version_t version);
int spice_server_set_port(SpiceServer *s, int port);
void spice_server_set_addr(SpiceServer *s, const char *addr, int flags);
-int spice_server_set_listen_socket_fd(SpiceServer *s, int listen_fd);
+int spice_server_set_listen_socket_fd(SpiceServer *s, int listen_fd) G_GNUC_DEPRECATED;
int spice_server_set_exit_on_disconnect(SpiceServer *s, int flag);
int spice_server_set_noauth(SpiceServer *s);
int spice_server_set_sasl(SpiceServer *s, int enabled);
@@ -97,7 +99,7 @@ int spice_server_set_zlib_glz_compression(SpiceServer *s, spice_wan_compression_
int spice_server_set_channel_security(SpiceServer *s, const char *channel, int security);
-int spice_server_add_renderer(SpiceServer *s, const char *name);
+int spice_server_add_renderer(SpiceServer *s, const char *name) G_GNUC_DEPRECATED;
enum {
SPICE_STREAM_VIDEO_INVALID,
@@ -112,8 +114,8 @@ int spice_server_set_agent_mouse(SpiceServer *s, int enable);
int spice_server_set_agent_copypaste(SpiceServer *s, int enable);
int spice_server_set_agent_file_xfer(SpiceServer *s, int enable);
-int spice_server_get_sock_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen);
-int spice_server_get_peer_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen);
+int spice_server_get_sock_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen) G_GNUC_DEPRECATED;
+int spice_server_get_peer_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen) G_GNUC_DEPRECATED;
int spice_server_is_server_mouse(SpiceServer *s);
@@ -123,6 +125,6 @@ void spice_server_set_uuid(SpiceServer *s, const uint8_t uuid[16]);
void spice_server_vm_start(SpiceServer *s);
void spice_server_vm_stop(SpiceServer *s);
-int spice_server_get_num_clients(SpiceServer *s);
+int spice_server_get_num_clients(SpiceServer *s) G_GNUC_DEPRECATED;
#endif /* SPICE_SERVER_H_ */
commit 4b45b74144427b33876b13ea157152d1ff7bffba
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Mar 5 15:11:00 2015 +0100
Add RedServerConfig
This wraps/groups the various parameters that can be set by spice-server
users through the spice_server_set_xxx public API.
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/reds-private.h b/server/reds-private.h
index 80e2c41..74a251b 100644
--- a/server/reds-private.h
+++ b/server/reds-private.h
@@ -89,8 +89,10 @@ typedef struct RedSSLParameters {
} RedSSLParameters;
typedef struct RedCharDeviceVDIPort RedCharDeviceVDIPort;
+typedef struct RedServerConfig RedServerConfig;
struct RedsState {
+ RedServerConfig *config;
int listen_socket;
int secure_listen_socket;
SpiceWatch *listen_watch;
@@ -117,7 +119,6 @@ struct RedsState {
between the 2 servers */
Ring mig_target_clients;
int num_mig_target_clients;
- RedsMigSpice *mig_spice;
int num_of_channels;
Ring channels;
@@ -146,40 +147,9 @@ struct RedsState {
int mm_time_enabled;
uint32_t mm_time_latency;
- int default_channel_security;
- ChannelSecurityOptions *channels_security;
- GArray *renderers;
-
- int spice_port;
- int spice_secure_port;
SpiceCharDeviceInstance *vdagent;
SpiceMigrateInstance *migration_interface;
- int spice_listen_socket_fd;
- char spice_addr[256];
- int spice_family;
- TicketAuthentication taTicket;
-
- int sasl_enabled;
-#if HAVE_SASL
- char *sasl_appname;
-#endif
- char *spice_name;
-
- bool spice_uuid_is_set;
- uint8_t spice_uuid[16];
-
- gboolean ticketing_enabled;
- uint32_t streaming_video;
- SpiceImageCompression image_compression;
- spice_wan_compression_t jpeg_state;
- spice_wan_compression_t zlib_glz_state;
-
- gboolean agent_mouse;
- gboolean agent_copypaste;
- gboolean agent_file_xfer;
- gboolean exit_on_disconnect;
- RedSSLParameters ssl_parameters;
SpiceCoreInterfaceInternal *core;
GList *qxl_instances;
MainDispatcher *main_dispatcher;
diff --git a/server/reds.c b/server/reds.c
index 97c77f7..1d98218 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -149,6 +149,46 @@ static long *lock_count;
* the intended use is to support a single server per process */
GList *servers = NULL;
+/* SPICE configuration set through the public spice_server_set_xxx APIS */
+struct RedServerConfig {
+ RedsMigSpice *mig_spice;
+
+ int default_channel_security;
+ ChannelSecurityOptions *channels_security;
+
+ GArray *renderers;
+
+ int spice_port;
+ int spice_secure_port;
+ int spice_listen_socket_fd;
+ char spice_addr[256];
+ int spice_family;
+ TicketAuthentication taTicket;
+
+ int sasl_enabled;
+#if HAVE_SASL
+ char *sasl_appname;
+#endif
+ char *spice_name;
+
+ bool spice_uuid_is_set;
+ uint8_t spice_uuid[16];
+
+ gboolean ticketing_enabled;
+ uint32_t streaming_video;
+ SpiceImageCompression image_compression;
+ spice_wan_compression_t jpeg_state;
+ spice_wan_compression_t zlib_glz_state;
+
+ gboolean agent_mouse;
+ gboolean agent_copypaste;
+ gboolean agent_file_xfer;
+ gboolean exit_on_disconnect;
+
+ RedSSLParameters ssl_parameters;
+};
+
+
typedef struct RedLinkInfo {
RedsState *reds;
RedsStream *stream;
@@ -266,7 +306,7 @@ static void vdi_port_read_buf_free(RedVDIReadBuf *buf);
static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int id)
{
- ChannelSecurityOptions *now = reds->channels_security;
+ ChannelSecurityOptions *now = reds->config->channels_security;
while (now && now->channel_id != id) {
now = now->next;
}
@@ -486,8 +526,8 @@ static void reds_reset_vdp(RedsState *reds)
dev->priv->current_read_buf = NULL;
}
/* Reset read filter to start with clean state when the agent reconnects */
- agent_msg_filter_init(&dev->priv->read_filter, reds->agent_copypaste,
- reds->agent_file_xfer,
+ agent_msg_filter_init(&dev->priv->read_filter, reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds), TRUE);
/* Throw away pending chunks from the current (if any) and future
* messages written by the client.
@@ -532,7 +572,7 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
{
RedsMigTargetClient *mig_client;
- if (reds->exit_on_disconnect)
+ if (reds->config->exit_on_disconnect)
{
spice_info("Exiting server because of client disconnect.\n");
exit(0);
@@ -600,8 +640,8 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
}
/* Reset write filter to start with clean state on client reconnect */
- agent_msg_filter_init(&reds->agent_dev->priv->write_filter, reds->agent_copypaste,
- reds->agent_file_xfer,
+ agent_msg_filter_init(&reds->agent_dev->priv->write_filter, reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds), TRUE);
/* Throw away pending chunks from the current (if any) and future
@@ -661,7 +701,7 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode)
gboolean reds_get_agent_mouse(const RedsState *reds)
{
- return reds->agent_mouse;
+ return reds->config->agent_mouse;
}
static void reds_update_mouse_mode(RedsState *reds)
@@ -669,7 +709,7 @@ static void reds_update_mouse_mode(RedsState *reds)
int allowed = 0;
int qxl_count = g_list_length(reds->qxl_instances);
- if ((reds->agent_mouse && reds->vdagent) ||
+ if ((reds->config->agent_mouse && reds->vdagent) ||
(inputs_channel_has_tablet(reds->inputs_channel) && qxl_count == 1)) {
allowed = reds->dispatcher_allows_client_mouse;
}
@@ -1028,8 +1068,8 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
num_tokens);
}
- agent_msg_filter_config(&reds->agent_dev->priv->write_filter, reds->agent_copypaste,
- reds->agent_file_xfer,
+ agent_msg_filter_config(&reds->agent_dev->priv->write_filter, reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds));
reds->agent_dev->priv->write_filter.discard_all = FALSE;
}
@@ -1440,7 +1480,7 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc,
static void reds_channel_init_auth_caps(RedLinkInfo *link, RedChannel *channel)
{
RedsState *reds = link->reds;
- if (reds->sasl_enabled && !link->skip_auth) {
+ if (reds->config->sasl_enabled && !link->skip_auth) {
red_channel_set_common_cap(channel, SPICE_COMMON_CAP_AUTH_SASL);
} else {
red_channel_set_common_cap(channel, SPICE_COMMON_CAP_AUTH_SPICE);
@@ -1502,7 +1542,7 @@ static int reds_send_link_ack(RedsState *reds, RedLinkInfo *link)
hdr_size += channel_caps->num_caps * sizeof(uint32_t);
header.size = GUINT32_TO_LE(hdr_size);
ack.caps_offset = GUINT32_TO_LE(sizeof(SpiceLinkReply));
- if (!reds->sasl_enabled
+ if (!reds->config->sasl_enabled
|| !red_link_info_test_capability(link, SPICE_COMMON_CAP_AUTH_SASL)) {
if (!(link->tiTicketing.rsa = RSA_new())) {
spice_warning("RSA new failed");
@@ -1764,8 +1804,8 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
spice_warning("unexpected: vdagent attached to destination during migration");
}
agent_msg_filter_config(&reds->agent_dev->priv->read_filter,
- reds->agent_copypaste,
- reds->agent_file_xfer,
+ reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds));
reds->agent_dev->priv->read_filter.discard_all = FALSE;
reds->agent_dev->priv->plug_generation++;
@@ -1776,10 +1816,10 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
- if (reds->spice_name)
- main_channel_push_name(mcc, reds->spice_name);
- if (reds->spice_uuid_is_set)
- main_channel_push_uuid(mcc, reds->spice_uuid);
+ if (reds->config->spice_name)
+ main_channel_push_name(mcc, reds->config->spice_name);
+ if (reds->config->spice_uuid_is_set)
+ main_channel_push_uuid(mcc, reds->config->spice_uuid);
} else {
reds_mig_target_client_add(reds, client);
}
@@ -2022,16 +2062,16 @@ static void reds_handle_ticket(void *opaque)
}
password[password_size] = '\0';
- if (reds->ticketing_enabled && !link->skip_auth) {
- int expired = reds->taTicket.expiration_time < ltime;
+ if (reds->config->ticketing_enabled && !link->skip_auth) {
+ int expired = reds->config->taTicket.expiration_time < ltime;
- if (strlen(reds->taTicket.password) == 0) {
+ if (strlen(reds->config->taTicket.password) == 0) {
spice_warning("Ticketing is enabled, but no password is set. "
"please set a ticket first");
goto error;
}
- if (expired || strcmp(password, reds->taTicket.password) != 0) {
+ if (expired || strcmp(password, reds->config->taTicket.password) != 0) {
if (expired) {
spice_warning("Ticket has expired");
} else {
@@ -2193,7 +2233,7 @@ static void reds_handle_auth_mechanism(void *opaque)
link->auth_mechanism.auth_mechanism = GUINT32_FROM_LE(link->auth_mechanism.auth_mechanism);
if (link->auth_mechanism.auth_mechanism == SPICE_COMMON_CAP_AUTH_SPICE
- && !reds->sasl_enabled
+ && !reds->config->sasl_enabled
) {
reds_get_spice_ticket(link);
#if HAVE_SASL
@@ -2203,7 +2243,7 @@ static void reds_handle_auth_mechanism(void *opaque)
#endif
} else {
spice_warning("Unknown auth method, disconnecting");
- if (reds->sasl_enabled) {
+ if (reds->config->sasl_enabled) {
spice_warning("Your client doesn't handle SASL?");
}
reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
@@ -2215,7 +2255,7 @@ static int reds_security_check(RedLinkInfo *link)
{
RedsState *reds = link->reds;
ChannelSecurityOptions *security_option = reds_find_channel_security(reds, link->link_mess->channel_type);
- uint32_t security = security_option ? security_option->options : reds->default_channel_security;
+ uint32_t security = security_option ? security_option->options : reds->config->default_channel_security;
return (reds_stream_is_ssl(link->stream) && (security & SPICE_CHANNEL_SECURITY_SSL)) ||
(!reds_stream_is_ssl(link->stream) && (security & SPICE_CHANNEL_SECURITY_NONE));
}
@@ -2270,7 +2310,7 @@ static void reds_handle_read_link_done(void *opaque)
}
if (!auth_selection) {
- if (reds->sasl_enabled && !link->skip_auth) {
+ if (reds->config->sasl_enabled && !link->skip_auth) {
spice_warning("SASL enabled, but peer supports only spice authentication");
reds_send_link_error(link, SPICE_LINK_ERR_VERSION_MISMATCH);
return;
@@ -2655,8 +2695,8 @@ void reds_set_client_mm_time_latency(RedsState *reds, RedClient *client, uint32_
static int reds_init_net(RedsState *reds)
{
- if (reds->spice_port != -1 || reds->spice_family == AF_UNIX) {
- reds->listen_socket = reds_init_socket(reds->spice_addr, reds->spice_port, reds->spice_family);
+ if (reds->config->spice_port != -1 || reds->config->spice_family == AF_UNIX) {
+ reds->listen_socket = reds_init_socket(reds->config->spice_addr, reds->config->spice_port, reds->config->spice_family);
if (-1 == reds->listen_socket) {
return -1;
}
@@ -2669,9 +2709,9 @@ static int reds_init_net(RedsState *reds)
}
}
- if (reds->spice_secure_port != -1) {
- reds->secure_listen_socket = reds_init_socket(reds->spice_addr, reds->spice_secure_port,
- reds->spice_family);
+ if (reds->config->spice_secure_port != -1) {
+ reds->secure_listen_socket = reds_init_socket(reds->config->spice_addr, reds->config->spice_secure_port,
+ reds->config->spice_family);
if (-1 == reds->secure_listen_socket) {
return -1;
}
@@ -2684,8 +2724,8 @@ static int reds_init_net(RedsState *reds)
}
}
- if (reds->spice_listen_socket_fd != -1 ) {
- reds->listen_socket = reds->spice_listen_socket_fd;
+ if (reds->config->spice_listen_socket_fd != -1 ) {
+ reds->listen_socket = reds->config->spice_listen_socket_fd;
reds->listen_watch = reds_core_watch_add(reds, reds->listen_socket,
SPICE_WATCH_EVENT_READ,
reds_accept, reds);
@@ -2727,7 +2767,7 @@ static int load_dh_params(SSL_CTX *ctx, char *file)
static int ssl_password_cb(char *buf, int size, int flags, void *userdata)
{
RedsState *reds = userdata;
- char *pass = reds->ssl_parameters.keyfile_password;
+ char *pass = reds->config->ssl_parameters.keyfile_password;
if (size < strlen(pass) + 1) {
return (0);
}
@@ -2802,32 +2842,32 @@ static int reds_init_ssl(RedsState *reds)
SSL_CTX_set_options(reds->ctx, ssl_options);
/* Load our keys and certificates*/
- return_code = SSL_CTX_use_certificate_chain_file(reds->ctx, reds->ssl_parameters.certs_file);
+ return_code = SSL_CTX_use_certificate_chain_file(reds->ctx, reds->config->ssl_parameters.certs_file);
if (return_code == 1) {
- spice_info("Loaded certificates from %s", reds->ssl_parameters.certs_file);
+ spice_info("Loaded certificates from %s", reds->config->ssl_parameters.certs_file);
} else {
- spice_warning("Could not load certificates from %s", reds->ssl_parameters.certs_file);
+ spice_warning("Could not load certificates from %s", reds->config->ssl_parameters.certs_file);
return -1;
}
SSL_CTX_set_default_passwd_cb(reds->ctx, ssl_password_cb);
SSL_CTX_set_default_passwd_cb_userdata(reds->ctx, reds);
- return_code = SSL_CTX_use_PrivateKey_file(reds->ctx, reds->ssl_parameters.private_key_file,
+ return_code = SSL_CTX_use_PrivateKey_file(reds->ctx, reds->config->ssl_parameters.private_key_file,
SSL_FILETYPE_PEM);
if (return_code == 1) {
- spice_info("Using private key from %s", reds->ssl_parameters.private_key_file);
+ spice_info("Using private key from %s", reds->config->ssl_parameters.private_key_file);
} else {
spice_warning("Could not use private key file");
return -1;
}
/* Load the CAs we trust*/
- return_code = SSL_CTX_load_verify_locations(reds->ctx, reds->ssl_parameters.ca_certificate_file, 0);
+ return_code = SSL_CTX_load_verify_locations(reds->ctx, reds->config->ssl_parameters.ca_certificate_file, 0);
if (return_code == 1) {
- spice_info("Loaded CA certificates from %s", reds->ssl_parameters.ca_certificate_file);
+ spice_info("Loaded CA certificates from %s", reds->config->ssl_parameters.ca_certificate_file);
} else {
- spice_warning("Could not use CA file %s", reds->ssl_parameters.ca_certificate_file);
+ spice_warning("Could not use CA file %s", reds->config->ssl_parameters.ca_certificate_file);
return -1;
}
@@ -2835,15 +2875,15 @@ static int reds_init_ssl(RedsState *reds)
SSL_CTX_set_verify_depth(reds->ctx, 1);
#endif
- if (strlen(reds->ssl_parameters.dh_key_file) > 0) {
- if (load_dh_params(reds->ctx, reds->ssl_parameters.dh_key_file) < 0) {
+ if (strlen(reds->config->ssl_parameters.dh_key_file) > 0) {
+ if (load_dh_params(reds->ctx, reds->config->ssl_parameters.dh_key_file) < 0) {
return -1;
}
}
SSL_CTX_set_session_id_context(reds->ctx, (const unsigned char *)"SPICE", 5);
- if (strlen(reds->ssl_parameters.ciphersuite) > 0) {
- if (!SSL_CTX_set_cipher_list(reds->ctx, reds->ssl_parameters.ciphersuite)) {
+ if (strlen(reds->config->ssl_parameters.ciphersuite) > 0) {
+ if (!SSL_CTX_set_cipher_list(reds->ctx, reds->config->ssl_parameters.ciphersuite)) {
return -1;
}
}
@@ -2881,7 +2921,7 @@ SPICE_DESTRUCTOR_FUNC(reds_exit)
static inline void on_activating_ticketing(RedsState *reds)
{
- if (!reds->ticketing_enabled && reds_main_channel_connected(reds)) {
+ if (!reds->config->ticketing_enabled && reds_main_channel_connected(reds)) {
spice_warning("disconnecting");
reds_disconnect(reds);
}
@@ -2889,10 +2929,10 @@ static inline void on_activating_ticketing(RedsState *reds)
static void reds_set_image_compression(RedsState *reds, SpiceImageCompression val)
{
- if (val == reds->image_compression) {
+ if (val == reds->config->image_compression) {
return;
}
- reds->image_compression = val;
+ reds->config->image_compression = val;
reds_on_ic_change(reds);
}
@@ -2907,26 +2947,26 @@ static void reds_set_one_channel_security(RedsState *reds, int id, uint32_t secu
security_options = spice_new(ChannelSecurityOptions, 1);
security_options->channel_id = id;
security_options->options = security;
- security_options->next = reds->channels_security;
- reds->channels_security = security_options;
+ security_options->next = reds->config->channels_security;
+ reds->config->channels_security = security_options;
}
#define REDS_SAVE_VERSION 1
static void reds_mig_release(RedsState *reds)
{
- if (reds->mig_spice) {
- free(reds->mig_spice->cert_subject);
- free(reds->mig_spice->host);
- free(reds->mig_spice);
- reds->mig_spice = NULL;
+ if (reds->config->mig_spice) {
+ free(reds->config->mig_spice->cert_subject);
+ free(reds->config->mig_spice->host);
+ free(reds->config->mig_spice);
+ reds->config->mig_spice = NULL;
}
}
static void reds_mig_started(RedsState *reds)
{
spice_info(NULL);
- spice_assert(reds->mig_spice);
+ spice_assert(reds->config->mig_spice);
reds->mig_inprogress = TRUE;
reds->mig_wait_connect = TRUE;
@@ -2996,11 +3036,11 @@ static void reds_mig_finished(RedsState *reds, int completed)
static void reds_mig_switch(RedsState *reds)
{
- if (!reds->mig_spice) {
+ if (!reds->config->mig_spice) {
spice_warning("reds_mig_switch called without migrate_info set");
return;
}
- main_channel_migrate_switch(reds->main_channel, reds->mig_spice);
+ main_channel_migrate_switch(reds->main_channel, reds->config->mig_spice);
reds_mig_release(reds);
}
@@ -3431,8 +3471,8 @@ static int do_spice_init(RedsState *reds, SpiceCoreInterface *core_interface)
}
#if HAVE_SASL
int saslerr;
- if ((saslerr = sasl_server_init(NULL, reds->sasl_appname ?
- reds->sasl_appname : "spice")) != SASL_OK) {
+ if ((saslerr = sasl_server_init(NULL, reds->config->sasl_appname ?
+ reds->config->sasl_appname : "spice")) != SASL_OK) {
spice_error("Failed to initialize SASL auth %s",
sasl_errstring(saslerr, NULL, NULL));
goto err;
@@ -3463,28 +3503,29 @@ static const char default_renderer[] = "sw";
SPICE_GNUC_VISIBLE SpiceServer *spice_server_new(void)
{
RedsState *reds = spice_new0(RedsState, 1);
- reds->default_channel_security =
+ reds->config = spice_new0(RedServerConfig, 1);
+ reds->config->default_channel_security =
SPICE_CHANNEL_SECURITY_NONE | SPICE_CHANNEL_SECURITY_SSL;
- reds->renderers = g_array_sized_new(FALSE, TRUE, sizeof(uint32_t), RED_RENDERER_LAST);
- reds->spice_port = -1;
- reds->spice_secure_port = -1;
- reds->spice_listen_socket_fd = -1;
- reds->spice_family = PF_UNSPEC;
- reds->sasl_enabled = 0; // sasl disabled by default
+ reds->config->renderers = g_array_sized_new(FALSE, TRUE, sizeof(uint32_t), RED_RENDERER_LAST);
+ reds->config->spice_port = -1;
+ reds->config->spice_secure_port = -1;
+ reds->config->spice_listen_socket_fd = -1;
+ reds->config->spice_family = PF_UNSPEC;
+ reds->config->sasl_enabled = 0; // sasl disabled by default
#if HAVE_SASL
- reds->sasl_appname = NULL; // default to "spice" if NULL
+ reds->config->sasl_appname = NULL; // default to "spice" if NULL
#endif
- reds->spice_uuid_is_set = FALSE;
- memset(reds->spice_uuid, 0, sizeof(reds->spice_uuid));
- reds->ticketing_enabled = TRUE; /* ticketing enabled by default */
- reds->streaming_video = SPICE_STREAM_VIDEO_FILTER;
- reds->image_compression = SPICE_IMAGE_COMPRESSION_AUTO_GLZ;
- reds->jpeg_state = SPICE_WAN_COMPRESSION_AUTO;
- reds->zlib_glz_state = SPICE_WAN_COMPRESSION_AUTO;
- reds->agent_mouse = TRUE;
- reds->agent_copypaste = TRUE;
- reds->agent_file_xfer = TRUE;
- reds->exit_on_disconnect = FALSE;
+ reds->config->spice_uuid_is_set = FALSE;
+ memset(reds->config->spice_uuid, 0, sizeof(reds->config->spice_uuid));
+ reds->config->ticketing_enabled = TRUE; /* ticketing enabled by default */
+ reds->config->streaming_video = SPICE_STREAM_VIDEO_FILTER;
+ reds->config->image_compression = SPICE_IMAGE_COMPRESSION_AUTO_GLZ;
+ reds->config->jpeg_state = SPICE_WAN_COMPRESSION_AUTO;
+ reds->config->zlib_glz_state = SPICE_WAN_COMPRESSION_AUTO;
+ reds->config->agent_mouse = TRUE;
+ reds->config->agent_copypaste = TRUE;
+ reds->config->agent_file_xfer = TRUE;
+ reds->config->exit_on_disconnect = FALSE;
return reds;
}
@@ -3514,10 +3555,10 @@ static int reds_add_renderer(RedsState *reds, const char *name)
{
const RendererInfo *inf;
- if (reds->renderers->len == RED_RENDERER_LAST || !(inf = find_renderer(name))) {
+ if (reds->config->renderers->len == RED_RENDERER_LAST || !(inf = find_renderer(name))) {
return FALSE;
}
- g_array_append_val(reds->renderers, inf->id);
+ g_array_append_val(reds->config->renderers, inf->id);
return TRUE;
}
@@ -3526,7 +3567,7 @@ SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *reds, SpiceCoreInterface *
int ret;
ret = do_spice_init(reds, core);
- if (reds->renderers->len == 0) {
+ if (reds->config->renderers->len == 0) {
reds_add_renderer(reds, default_renderer);
}
return ret;
@@ -3534,7 +3575,8 @@ SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *reds, SpiceCoreInterface *
SPICE_GNUC_VISIBLE void spice_server_destroy(SpiceServer *reds)
{
- g_array_unref(reds->renderers);
+ g_array_unref(reds->config->renderers);
+ free(reds->config);
if (reds->main_channel) {
main_channel_close(reds->main_channel);
}
@@ -3570,20 +3612,20 @@ SPICE_GNUC_VISIBLE int spice_server_set_port(SpiceServer *reds, int port)
if (port < 0 || port > 0xffff) {
return -1;
}
- reds->spice_port = port;
+ reds->config->spice_port = port;
return 0;
}
SPICE_GNUC_VISIBLE void spice_server_set_addr(SpiceServer *reds, const char *addr, int flags)
{
- g_strlcpy(reds->spice_addr, addr, sizeof(reds->spice_addr));
+ g_strlcpy(reds->config->spice_addr, addr, sizeof(reds->config->spice_addr));
if (flags == SPICE_ADDR_FLAG_IPV4_ONLY) {
- reds->spice_family = PF_INET;
+ reds->config->spice_family = PF_INET;
} else if (flags == SPICE_ADDR_FLAG_IPV6_ONLY) {
- reds->spice_family = PF_INET6;
+ reds->config->spice_family = PF_INET6;
} else if (flags == SPICE_ADDR_FLAG_UNIX_ONLY) {
- reds->spice_family = AF_UNIX;
+ reds->config->spice_family = AF_UNIX;
} else if (flags != 0) {
spice_warning("unknown address flag: 0x%X", flags);
}
@@ -3591,27 +3633,27 @@ SPICE_GNUC_VISIBLE void spice_server_set_addr(SpiceServer *reds, const char *add
SPICE_GNUC_VISIBLE int spice_server_set_listen_socket_fd(SpiceServer *s, int listen_fd)
{
- s->spice_listen_socket_fd = listen_fd;
+ s->config->spice_listen_socket_fd = listen_fd;
return 0;
}
SPICE_GNUC_VISIBLE int spice_server_set_exit_on_disconnect(SpiceServer *s, int flag)
{
- s->exit_on_disconnect = !!flag;
+ s->config->exit_on_disconnect = !!flag;
return 0;
}
SPICE_GNUC_VISIBLE int spice_server_set_noauth(SpiceServer *s)
{
- memset(s->taTicket.password, 0, sizeof(s->taTicket.password));
- s->ticketing_enabled = FALSE;
+ memset(s->config->taTicket.password, 0, sizeof(s->config->taTicket.password));
+ s->config->ticketing_enabled = FALSE;
return 0;
}
SPICE_GNUC_VISIBLE int spice_server_set_sasl(SpiceServer *s, int enabled)
{
#if HAVE_SASL
- s->sasl_enabled = enabled;
+ s->config->sasl_enabled = enabled;
return 0;
#else
return -1;
@@ -3621,8 +3663,8 @@ SPICE_GNUC_VISIBLE int spice_server_set_sasl(SpiceServer *s, int enabled)
SPICE_GNUC_VISIBLE int spice_server_set_sasl_appname(SpiceServer *s, const char *appname)
{
#if HAVE_SASL
- free(s->sasl_appname);
- s->sasl_appname = spice_strdup(appname);
+ free(s->config->sasl_appname);
+ s->config->sasl_appname = spice_strdup(appname);
return 0;
#else
return -1;
@@ -3631,14 +3673,14 @@ SPICE_GNUC_VISIBLE int spice_server_set_sasl_appname(SpiceServer *s, const char
SPICE_GNUC_VISIBLE void spice_server_set_name(SpiceServer *s, const char *name)
{
- free(s->spice_name);
- s->spice_name = spice_strdup(name);
+ free(s->config->spice_name);
+ s->config->spice_name = spice_strdup(name);
}
SPICE_GNUC_VISIBLE void spice_server_set_uuid(SpiceServer *s, const uint8_t uuid[16])
{
- memcpy(s->spice_uuid, uuid, sizeof(s->spice_uuid));
- s->spice_uuid_is_set = TRUE;
+ memcpy(s->config->spice_uuid, uuid, sizeof(s->config->spice_uuid));
+ s->config->spice_uuid_is_set = TRUE;
}
SPICE_GNUC_VISIBLE int spice_server_set_ticket(SpiceServer *reds,
@@ -3656,20 +3698,20 @@ SPICE_GNUC_VISIBLE int spice_server_set_ticket(SpiceServer *reds,
}
on_activating_ticketing(reds);
- reds->ticketing_enabled = TRUE;
+ reds->config->ticketing_enabled = TRUE;
if (lifetime == 0) {
- reds->taTicket.expiration_time = INT_MAX;
+ reds->config->taTicket.expiration_time = INT_MAX;
} else {
time_t now = time(NULL);
- reds->taTicket.expiration_time = now + lifetime;
+ reds->config->taTicket.expiration_time = now + lifetime;
}
if (passwd != NULL) {
if (strlen(passwd) > SPICE_MAX_PASSWORD_LENGTH)
return -1;
- g_strlcpy(reds->taTicket.password, passwd, sizeof(reds->taTicket.password));
+ g_strlcpy(reds->config->taTicket.password, passwd, sizeof(reds->config->taTicket.password));
} else {
- memset(reds->taTicket.password, 0, sizeof(reds->taTicket.password));
- reds->taTicket.expiration_time = 0;
+ memset(reds->config->taTicket.password, 0, sizeof(reds->config->taTicket.password));
+ reds->config->taTicket.expiration_time = 0;
}
return 0;
}
@@ -3686,27 +3728,27 @@ SPICE_GNUC_VISIBLE int spice_server_set_tls(SpiceServer *s, int port,
if (port < 0 || port > 0xffff) {
return -1;
}
- memset(&s->ssl_parameters, 0, sizeof(s->ssl_parameters));
+ memset(&s->config->ssl_parameters, 0, sizeof(s->config->ssl_parameters));
- s->spice_secure_port = port;
- g_strlcpy(s->ssl_parameters.ca_certificate_file, ca_cert_file,
- sizeof(s->ssl_parameters.ca_certificate_file));
- g_strlcpy(s->ssl_parameters.certs_file, certs_file,
- sizeof(s->ssl_parameters.certs_file));
- g_strlcpy(s->ssl_parameters.private_key_file, private_key_file,
- sizeof(s->ssl_parameters.private_key_file));
+ s->config->spice_secure_port = port;
+ g_strlcpy(s->config->ssl_parameters.ca_certificate_file, ca_cert_file,
+ sizeof(s->config->ssl_parameters.ca_certificate_file));
+ g_strlcpy(s->config->ssl_parameters.certs_file, certs_file,
+ sizeof(s->config->ssl_parameters.certs_file));
+ g_strlcpy(s->config->ssl_parameters.private_key_file, private_key_file,
+ sizeof(s->config->ssl_parameters.private_key_file));
if (key_passwd) {
- g_strlcpy(s->ssl_parameters.keyfile_password, key_passwd,
- sizeof(s->ssl_parameters.keyfile_password));
+ g_strlcpy(s->config->ssl_parameters.keyfile_password, key_passwd,
+ sizeof(s->config->ssl_parameters.keyfile_password));
}
if (ciphersuite) {
- g_strlcpy(s->ssl_parameters.ciphersuite, ciphersuite,
- sizeof(s->ssl_parameters.ciphersuite));
+ g_strlcpy(s->config->ssl_parameters.ciphersuite, ciphersuite,
+ sizeof(s->config->ssl_parameters.ciphersuite));
}
if (dh_key_file) {
- g_strlcpy(s->ssl_parameters.dh_key_file, dh_key_file,
- sizeof(s->ssl_parameters.dh_key_file));
+ g_strlcpy(s->config->ssl_parameters.dh_key_file, dh_key_file,
+ sizeof(s->config->ssl_parameters.dh_key_file));
}
return 0;
}
@@ -3728,7 +3770,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_image_compression(SpiceServer *s,
SPICE_GNUC_VISIBLE SpiceImageCompression spice_server_get_image_compression(SpiceServer *s)
{
- return s->image_compression;
+ return s->config->image_compression;
}
SPICE_GNUC_VISIBLE int spice_server_set_jpeg_compression(SpiceServer *s, spice_wan_compression_t comp)
@@ -3738,7 +3780,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_jpeg_compression(SpiceServer *s, spice_w
return -1;
}
// todo: support dynamically changing the state
- s->jpeg_state = comp;
+ s->config->jpeg_state = comp;
return 0;
}
@@ -3749,7 +3791,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_zlib_glz_compression(SpiceServer *s, spi
return -1;
}
// todo: support dynamically changing the state
- s->zlib_glz_state = comp;
+ s->config->zlib_glz_state = comp;
return 0;
}
@@ -3771,7 +3813,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_channel_security(SpiceServer *s, const c
int i;
if (channel == NULL) {
- s->default_channel_security = security;
+ s->config->default_channel_security = security;
return 0;
}
for (i = 0; i < SPICE_N_ELEMENTS(names); i++) {
@@ -3825,14 +3867,14 @@ SPICE_GNUC_VISIBLE int spice_server_set_streaming_video(SpiceServer *reds, int v
value != SPICE_STREAM_VIDEO_ALL &&
value != SPICE_STREAM_VIDEO_FILTER)
return -1;
- reds->streaming_video = value;
+ reds->config->streaming_video = value;
reds_on_sv_change(reds);
return 0;
}
uint32_t reds_get_streaming_video(const RedsState *reds)
{
- return reds->streaming_video;
+ return reds->config->streaming_video;
}
SPICE_GNUC_VISIBLE int spice_server_set_playback_compression(SpiceServer *reds, int enable)
@@ -3843,24 +3885,24 @@ SPICE_GNUC_VISIBLE int spice_server_set_playback_compression(SpiceServer *reds,
SPICE_GNUC_VISIBLE int spice_server_set_agent_mouse(SpiceServer *reds, int enable)
{
- reds->agent_mouse = enable;
+ reds->config->agent_mouse = enable;
reds_update_mouse_mode(reds);
return 0;
}
SPICE_GNUC_VISIBLE int spice_server_set_agent_copypaste(SpiceServer *reds, int enable)
{
- reds->agent_copypaste = enable;
- reds->agent_dev->priv->write_filter.copy_paste_enabled = reds->agent_copypaste;
- reds->agent_dev->priv->read_filter.copy_paste_enabled = reds->agent_copypaste;
+ reds->config->agent_copypaste = enable;
+ reds->agent_dev->priv->write_filter.copy_paste_enabled = reds->config->agent_copypaste;
+ reds->agent_dev->priv->read_filter.copy_paste_enabled = reds->config->agent_copypaste;
return 0;
}
SPICE_GNUC_VISIBLE int spice_server_set_agent_file_xfer(SpiceServer *reds, int enable)
{
- reds->agent_file_xfer = enable;
- reds->agent_dev->priv->write_filter.file_xfer_enabled = reds->agent_file_xfer;
- reds->agent_dev->priv->read_filter.file_xfer_enabled = reds->agent_file_xfer;
+ reds->config->agent_file_xfer = enable;
+ reds->agent_dev->priv->write_filter.file_xfer_enabled = reds->config->agent_file_xfer;
+ reds->agent_dev->priv->read_filter.file_xfer_enabled = reds->config->agent_file_xfer;
return 0;
}
@@ -3885,7 +3927,7 @@ static int reds_set_migration_dest_info(RedsState *reds,
spice_migration->cert_subject = spice_strdup(cert_subject);
}
- reds->mig_spice = spice_migration;
+ reds->config->mig_spice = spice_migration;
return TRUE;
}
@@ -3927,7 +3969,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_connect(SpiceServer *reds, const cha
red_channel_test_remote_cap(&reds->main_channel->base,
SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS);
/* main channel will take care of clients that are still during migration (at target)*/
- if (main_channel_migrate_connect(reds->main_channel, reds->mig_spice,
+ if (main_channel_migrate_connect(reds->main_channel, reds->config->mig_spice,
try_seamless)) {
reds_mig_started(reds);
} else {
@@ -3957,7 +3999,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_info(SpiceServer *reds, const char*
SPICE_GNUC_VISIBLE int spice_server_migrate_start(SpiceServer *reds)
{
spice_info(NULL);
- if (!reds->mig_spice) {
+ if (!reds->config->mig_spice) {
return -1;
}
return 0;
@@ -4037,17 +4079,17 @@ SPICE_GNUC_VISIBLE void spice_server_set_seamless_migration(SpiceServer *reds, i
GArray* reds_get_renderers(RedsState *reds)
{
- return reds->renderers;
+ return reds->config->renderers;
}
spice_wan_compression_t reds_get_jpeg_state(const RedsState *reds)
{
- return reds->jpeg_state;
+ return reds->config->jpeg_state;
}
spice_wan_compression_t reds_get_zlib_glz_state(const RedsState *reds)
{
- return reds->zlib_glz_state;
+ return reds->config->zlib_glz_state;
}
SpiceCoreInterfaceInternal* reds_get_core_interface(RedsState *reds)
@@ -4267,12 +4309,12 @@ static void red_char_device_vdi_port_constructed(GObject *object)
g_object_get(dev, "spice-server", &reds, NULL);
- agent_msg_filter_init(&dev->priv->write_filter, reds->agent_copypaste,
- reds->agent_file_xfer,
+ agent_msg_filter_init(&dev->priv->write_filter, reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds),
TRUE);
- agent_msg_filter_init(&dev->priv->read_filter, reds->agent_copypaste,
- reds->agent_file_xfer,
+ agent_msg_filter_init(&dev->priv->read_filter, reds->config->agent_copypaste,
+ reds->config->agent_file_xfer,
reds_use_client_monitors_config(reds),
TRUE);
}
commit 920e117c246ce52a31f80bad66e33df744c10a19
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Apr 14 14:39:10 2016 -0500
Rename all RedPipeItem subclasses
Use 'Red' prefix to match internal type naming convention
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/cache-item.h b/server/cache-item.h
index 90c82d3..7dde902 100644
--- a/server/cache-item.h
+++ b/server/cache-item.h
@@ -21,14 +21,14 @@
#include "red-channel.h"
#include "common/ring.h"
-typedef struct CacheItem CacheItem;
+typedef struct RedCacheItem RedCacheItem;
-struct CacheItem {
+struct RedCacheItem {
union {
RedPipeItem pipe_data;
struct {
RingItem lru_link;
- CacheItem *next;
+ RedCacheItem *next;
} cache_data;
} u;
uint64_t id;
diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
index d63e576..0617bea 100644
--- a/server/cache-item.tmpl.c
+++ b/server/cache-item.tmpl.c
@@ -48,9 +48,9 @@
#define CHANNEL_FROM_RCC(rcc) SPICE_CONTAINEROF((rcc)->channel, CHANNEL, common.base);
-static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
+static RedCacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
{
- CacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
+ RedCacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
while (item) {
if (item->id == id) {
@@ -63,9 +63,9 @@ static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
return item;
}
-static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
+static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
{
- CacheItem **now;
+ RedCacheItem **now;
spice_assert(item);
now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)];
@@ -81,20 +81,20 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
channel_client->VAR_NAME(items)--;
channel_client->VAR_NAME(available) += item->size;
- red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
+ red_pipe_item_init(&item->u.pipe_data, RED_PIPE_ITEM_TYPE_INVAL_ONE);
red_channel_client_pipe_add_tail_and_push(&channel_client->common.base, &item->u.pipe_data); // for now
}
static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t size)
{
- CacheItem *item;
+ RedCacheItem *item;
int key;
- item = spice_new(CacheItem, 1);
+ item = spice_new(RedCacheItem, 1);
channel_client->VAR_NAME(available) -= size;
while (channel_client->VAR_NAME(available) < 0) {
- CacheItem *tail = (CacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
+ RedCacheItem *tail = (RedCacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
if (!tail) {
channel_client->VAR_NAME(available) += size;
free(item);
@@ -119,7 +119,7 @@ static void FUNC_NAME(reset)(CHANNELCLIENT *channel_client, long size)
for (i = 0; i < CACHE_HASH_SIZE; i++) {
while (channel_client->CACHE_NAME[i]) {
- CacheItem *item = channel_client->CACHE_NAME[i];
+ RedCacheItem *item = channel_client->CACHE_NAME[i];
channel_client->CACHE_NAME[i] = item->u.cache_data.next;
free(item);
}
diff --git a/server/cursor-channel.c b/server/cursor-channel.c
index e2bb706..697d61d 100644
--- a/server/cursor-channel.c
+++ b/server/cursor-channel.c
@@ -32,9 +32,9 @@
#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
enum {
- PIPE_ITEM_TYPE_CURSOR = PIPE_ITEM_TYPE_COMMON_LAST,
- PIPE_ITEM_TYPE_CURSOR_INIT,
- PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
+ RED_PIPE_ITEM_TYPE_CURSOR = RED_PIPE_ITEM_TYPE_COMMON_LAST,
+ RED_PIPE_ITEM_TYPE_CURSOR_INIT,
+ RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
};
typedef struct CursorItem {
@@ -45,11 +45,11 @@ typedef struct CursorItem {
G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
-typedef struct CursorPipeItem {
+typedef struct RedCursorPipeItem {
RedPipeItem base;
CursorItem *cursor_item;
int refs;
-} CursorPipeItem;
+} RedCursorPipeItem;
struct CursorChannel {
CommonGraphicsChannel common; // Must be the first thing
@@ -69,7 +69,7 @@ struct CursorChannel {
struct CursorChannelClient {
CommonGraphicsChannelClient common;
- CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
+ RedCacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
Ring cursor_cache_lru;
long cursor_cache_available;
uint32_t cursor_cache_items;
@@ -134,9 +134,9 @@ static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
{
- CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
+ RedCursorPipeItem *item = spice_malloc0(sizeof(RedCursorPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_CURSOR);
item->refs = 1;
item->cursor_item = data;
item->cursor_item->refs++;
@@ -203,7 +203,8 @@ void cursor_channel_disconnect(CursorChannel *cursor_channel)
}
-static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_item)
+static void put_cursor_pipe_item(CursorChannelClient *ccc,
+ RedCursorPipeItem *pipe_item)
{
spice_return_if_fail(pipe_item);
spice_return_if_fail(pipe_item->refs > 0);
@@ -232,15 +233,15 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_CURSOR: {
- CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ case RED_PIPE_ITEM_TYPE_CURSOR: {
+ RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- case PIPE_ITEM_TYPE_VERB:
- case PIPE_ITEM_TYPE_CURSOR_INIT:
- case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ case RED_PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
+ case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
free(item);
break;
default:
@@ -252,8 +253,8 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_CURSOR: {
- CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ case RED_PIPE_ITEM_TYPE_CURSOR: {
+ RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
@@ -285,7 +286,8 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas
}
static void cursor_marshall(RedChannelClient *rcc,
- SpiceMarshaller *m, CursorPipeItem *cursor_pipe_item)
+ SpiceMarshaller *m,
+ RedCursorPipeItem *cursor_pipe_item)
{
CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@@ -338,7 +340,8 @@ static void cursor_marshall(RedChannelClient *rcc,
}
static inline void red_marshall_inval(RedChannelClient *rcc,
- SpiceMarshaller *base_marshaller, CacheItem *cach_item)
+ SpiceMarshaller *base_marshaller,
+ RedCacheItem *cach_item)
{
SpiceMsgDisplayInvalOne inval_one;
@@ -354,20 +357,20 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
switch (pipe_item->type) {
- case PIPE_ITEM_TYPE_CURSOR:
- cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, CursorPipeItem, base));
+ case RED_PIPE_ITEM_TYPE_CURSOR:
+ cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, RedCursorPipeItem, base));
break;
- case PIPE_ITEM_TYPE_INVAL_ONE:
- red_marshall_inval(rcc, m, (CacheItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ red_marshall_inval(rcc, m, (RedCacheItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_VERB:
- red_marshall_verb(rcc, (VerbItem*)pipe_item);
+ case RED_PIPE_ITEM_TYPE_VERB:
+ red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
- case PIPE_ITEM_TYPE_CURSOR_INIT:
+ case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
red_reset_cursor_cache(rcc);
red_marshall_cursor_init(rcc, m, pipe_item);
break;
- case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
red_reset_cursor_cache(rcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INVAL_ALL, NULL);
break;
@@ -379,7 +382,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
red_channel_client_begin_send_message(rcc);
}
-static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
+static RedCursorPipeItem *cursor_pipe_item_ref(RedCursorPipeItem *item)
{
spice_return_val_if_fail(item, NULL);
spice_return_val_if_fail(item->refs > 0, NULL);
@@ -391,11 +394,11 @@ static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
- CursorPipeItem *cursor_pipe_item;
+ RedCursorPipeItem *cursor_pipe_item;
spice_return_if_fail(item);
- cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
cursor_pipe_item_ref(cursor_pipe_item);
}
@@ -443,7 +446,7 @@ void cursor_channel_client_migrate(CursorChannelClient* client)
spice_return_if_fail(client);
rcc = RED_CHANNEL_CLIENT(client);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
red_channel_client_default_migrate(rcc);
}
@@ -531,7 +534,7 @@ void cursor_channel_reset(CursorChannel *cursor)
cursor->cursor_trail_length = cursor->cursor_trail_frequency = 0;
if (red_channel_is_connected(channel)) {
- red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+ red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
if (!cursor->common.during_target_migrate) {
red_pipes_add_verb(channel, SPICE_MSG_CURSOR_RESET);
}
@@ -555,9 +558,9 @@ void cursor_channel_init(CursorChannel *cursor, CursorChannelClient *client)
if (client)
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(client),
- PIPE_ITEM_TYPE_CURSOR_INIT);
+ RED_PIPE_ITEM_TYPE_CURSOR_INIT);
else
- red_channel_pipes_add_type(RED_CHANNEL(cursor), PIPE_ITEM_TYPE_CURSOR_INIT);
+ red_channel_pipes_add_type(RED_CHANNEL(cursor), RED_PIPE_ITEM_TYPE_CURSOR_INIT);
}
void cursor_channel_set_mouse_mode(CursorChannel *cursor, uint32_t mode)
diff --git a/server/dcc-send.c b/server/dcc-send.c
index 799d5df..efbc454 100644
--- a/server/dcc-send.c
+++ b/server/dcc-send.c
@@ -514,7 +514,7 @@ static void fill_attr(SpiceMarshaller *m, SpiceLineAttr *attr)
static void marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -608,9 +608,9 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
{
Drawable *drawable;
- if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
+ if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
- drawable = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item)->drawable;
+ drawable = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item)->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@@ -699,12 +699,12 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
pipe_item;
pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
Drawable *drawable;
- DrawablePipeItem *dpi;
- ImageItem *image;
+ RedDrawablePipeItem *dpi;
+ RedImageItem *image;
- if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
+ if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
- dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
+ dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@@ -803,7 +803,7 @@ static void red_add_lossless_drawable_dependencies(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *m,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -860,7 +860,8 @@ static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi, int src_allowed_lossy)
+ RedDrawablePipeItem *dpi,
+ int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -893,7 +894,7 @@ static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *m,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -958,7 +959,8 @@ static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi, int src_allowed_lossy)
+ RedDrawablePipeItem *dpi,
+ int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -984,7 +986,7 @@ static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -1009,7 +1011,7 @@ static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -1029,7 +1031,7 @@ static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1056,7 +1058,7 @@ static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi,
+ RedDrawablePipeItem *dpi,
int src_allowed_lossy)
{
Drawable *item = dpi->drawable;
@@ -1081,7 +1083,7 @@ static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1108,7 +1110,7 @@ static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1123,7 +1125,7 @@ static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1152,7 +1154,7 @@ static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1176,7 +1178,7 @@ static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1218,7 +1220,7 @@ static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1238,7 +1240,7 @@ static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1252,7 +1254,7 @@ static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1272,7 +1274,7 @@ static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1312,7 +1314,7 @@ static void red_lossy_marshall_qxl_draw_inverse(RedChannelClient *rcc,
static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1341,7 +1343,7 @@ static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1396,7 +1398,7 @@ static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1421,7 +1423,7 @@ static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1477,7 +1479,7 @@ static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1502,7 +1504,7 @@ static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1557,7 +1559,7 @@ static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1584,7 +1586,7 @@ static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1768,8 +1770,8 @@ static int red_marshall_stream_data(RedChannelClient *rcc,
}
static inline void marshall_inval_palette(RedChannelClient *rcc,
- SpiceMarshaller *base_marshaller,
- CacheItem *cache_item)
+ SpiceMarshaller *base_marshaller,
+ RedCacheItem *cache_item)
{
SpiceMsgDisplayInvalOne inval_one;
@@ -1915,7 +1917,9 @@ static void display_channel_marshall_reset_cache(RedChannelClient *rcc,
&wait);
}
-static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageItem *item)
+static void red_marshall_image(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ RedImageItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display = DCC_TO_DC(dcc);
@@ -2009,7 +2013,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI
static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
switch (item->red_drawable->type) {
@@ -2061,7 +2065,8 @@ static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
- SpiceMarshaller *m, DrawablePipeItem *dpi)
+ SpiceMarshaller *m,
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -2115,7 +2120,8 @@ static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_qxl_drawable(RedChannelClient *rcc,
- SpiceMarshaller *m, DrawablePipeItem *dpi)
+ SpiceMarshaller *m,
+ RedDrawablePipeItem *dpi)
{
spice_return_if_fail(rcc);
@@ -2173,7 +2179,7 @@ static void marshall_stream_start(RedChannelClient *rcc,
static void marshall_stream_clip(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- StreamClipItem *item)
+ RedStreamClipItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
StreamAgent *agent = item->stream_agent;
@@ -2203,7 +2209,7 @@ static void marshall_stream_end(RedChannelClient *rcc,
}
static void marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller *m,
- UpgradeItem *item)
+ RedUpgradeItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
RedDrawable *red_drawable;
@@ -2319,7 +2325,7 @@ static void marshall_gl_draw(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
+ RedGlDrawItem *p = SPICE_CONTAINEROF(item, RedGlDrawItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_DRAW, NULL);
spice_marshall_msg_display_gl_draw(m, &p->draw);
@@ -2367,80 +2373,81 @@ void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
reset_send_data(dcc);
switch (pipe_item->type) {
- case PIPE_ITEM_TYPE_DRAW: {
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
+ case RED_PIPE_ITEM_TYPE_DRAW: {
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
marshall_qxl_drawable(rcc, m, dpi);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- marshall_inval_palette(rcc, m, (CacheItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ marshall_inval_palette(rcc, m, (RedCacheItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_STREAM_CREATE: {
+ case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, create_item);
marshall_stream_start(rcc, m, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CLIP: {
- StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP: {
+ RedStreamClipItem* clip_item = (RedStreamClipItem *)pipe_item;
marshall_stream_clip(rcc, m, clip_item);
break;
}
- case PIPE_ITEM_TYPE_STREAM_DESTROY: {
+ case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, destroy_item);
marshall_stream_end(rcc, m, agent);
break;
}
- case PIPE_ITEM_TYPE_UPGRADE:
- marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
+ marshall_upgrade(rcc, m, (RedUpgradeItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_VERB:
- red_marshall_verb(rcc, (VerbItem*)pipe_item);
+ case RED_PIPE_ITEM_TYPE_VERB:
+ red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
- case PIPE_ITEM_TYPE_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
display_channel_marshall_migrate_data(rcc, m);
break;
- case PIPE_ITEM_TYPE_IMAGE:
- red_marshall_image(rcc, m, (ImageItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ red_marshall_image(rcc, m, (RedImageItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_PIXMAP_SYNC:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
display_channel_marshall_pixmap_sync(rcc, m);
break;
- case PIPE_ITEM_TYPE_PIXMAP_RESET:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
display_channel_marshall_reset_cache(rcc, m);
break;
- case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
dcc_palette_cache_reset(dcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, NULL);
break;
- case PIPE_ITEM_TYPE_CREATE_SURFACE: {
- SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, SurfaceCreateItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
+ RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, RedSurfaceCreateItem,
+ pipe_item);
marshall_surface_create(rcc, m, &surface_create->surface_create);
break;
}
- case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
- SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, SurfaceDestroyItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
+ RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, RedSurfaceDestroyItem,
+ pipe_item);
marshall_surface_destroy(rcc, m, surface_destroy->surface_destroy.surface_id);
break;
}
- case PIPE_ITEM_TYPE_MONITORS_CONFIG: {
- MonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
- MonitorsConfigItem, pipe_item);
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG: {
+ RedMonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
+ RedMonitorsConfigItem,
+ pipe_item);
marshall_monitors_config(rcc, m, monconf_item->monitors_config);
break;
}
- case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
- StreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
- StreamActivateReportItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
+ RedStreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
+ RedStreamActivateReportItem,
+ pipe_item);
marshall_stream_activate_report(rcc, m, report_item->stream_id);
break;
}
- case PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
marshall_gl_scanout(rcc, m, pipe_item);
break;
- case PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
marshall_gl_draw(rcc, m, pipe_item);
break;
default:
diff --git a/server/dcc.c b/server/dcc.c
index 330127b..038d74d 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -24,13 +24,16 @@
#define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano
-static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
- uint32_t surface_id, uint32_t width,
- uint32_t height, uint32_t format, uint32_t flags)
+static RedSurfaceCreateItem *red_surface_create_item_new(RedChannel* channel,
+ uint32_t surface_id,
+ uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ uint32_t flags)
{
- SurfaceCreateItem *create;
+ RedSurfaceCreateItem *create;
- create = spice_malloc(sizeof(SurfaceCreateItem));
+ create = spice_malloc(sizeof(RedSurfaceCreateItem));
create->surface_create.surface_id = surface_id;
create->surface_create.width = width;
@@ -38,13 +41,13 @@ static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
create->surface_create.flags = flags;
create->surface_create.format = format;
- red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
+ red_pipe_item_init(&create->pipe_item, RED_PIPE_ITEM_TYPE_CREATE_SURFACE);
return create;
}
int dcc_drawable_is_in_pipe(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *dpi_link, *dpi_next;
DRAWABLE_FOREACH_DPI_SAFE(drawable, dpi_link, dpi_next, dpi) {
@@ -77,14 +80,14 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
item = (RedPipeItem *) ring;
while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
Drawable *drawable;
- DrawablePipeItem *dpi = NULL;
+ RedDrawablePipeItem *dpi = NULL;
int depend_found = FALSE;
- if (item->type == PIPE_ITEM_TYPE_DRAW) {
- dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ if (item->type == RED_PIPE_ITEM_TYPE_DRAW) {
+ dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
- } else if (item->type == PIPE_ITEM_TYPE_UPGRADE) {
- drawable = ((UpgradeItem *)item)->drawable;
+ } else if (item->type == RED_PIPE_ITEM_TYPE_UPGRADE) {
+ drawable = ((RedUpgradeItem *)item)->drawable;
} else {
continue;
}
@@ -138,7 +141,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
{
DisplayChannel *display;
RedSurface *surface;
- SurfaceCreateItem *create;
+ RedSurfaceCreateItem *create;
uint32_t flags;
if (!dcc) {
@@ -154,21 +157,25 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
return;
}
surface = &display->surfaces[surface_id];
- create = surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
- surface_id, surface->context.width, surface->context.height,
- surface->context.format, flags);
+ create = red_surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
+ surface_id, surface->context.width,
+ surface->context.height,
+ surface->context.format, flags);
dcc->surface_client_created[surface_id] = TRUE;
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &create->pipe_item);
}
// adding the pipe item after pos. If pos == NULL, adding to head.
-ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
- SpiceRect *area, RedPipeItem *pos, int can_lossy)
+RedImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc,
+ int surface_id,
+ SpiceRect *area,
+ RedPipeItem *pos,
+ int can_lossy)
{
DisplayChannel *display = DCC_TO_DC(dcc);
RedSurface *surface = &display->surfaces[surface_id];
SpiceCanvas *canvas = surface->context.canvas;
- ImageItem *item;
+ RedImageItem *item;
int stride;
int width;
int height;
@@ -182,9 +189,9 @@ ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
bpp = SPICE_SURFACE_FMT_DEPTH(surface->context.format) / 8;
stride = width * bpp;
- item = (ImageItem *)spice_malloc_n_m(height, stride, sizeof(ImageItem));
+ item = (RedImageItem *)spice_malloc_n_m(height, stride, sizeof(RedImageItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_IMAGE);
item->surface_id = surface_id;
item->image_format =
@@ -274,9 +281,10 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
dcc_push_surface_image(dcc, drawable->surface_id);
}
-void drawable_pipe_item_free(RedPipeItem *item)
+void red_drawable_pipe_item_free(RedPipeItem *item)
{
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem,
+ dpi_pipe_item);
spice_assert(item->refcount == 0);
spice_warn_if_fail(!ring_item_is_linked(&item->link));
@@ -285,24 +293,25 @@ void drawable_pipe_item_free(RedPipeItem *item)
free(dpi);
}
-static DrawablePipeItem *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawable *drawable)
+static RedDrawablePipeItem *red_drawable_pipe_item_new(DisplayChannelClient *dcc,
+ Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
dpi = spice_malloc0(sizeof(*dpi));
dpi->drawable = drawable;
dpi->dcc = dcc;
ring_item_init(&dpi->base);
ring_add(&drawable->pipes, &dpi->base);
- red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
- (GDestroyNotify)drawable_pipe_item_free);
+ red_pipe_item_init_full(&dpi->dpi_pipe_item, RED_PIPE_ITEM_TYPE_DRAW,
+ (GDestroyNotify)red_drawable_pipe_item_free);
drawable->refs++;
return dpi;
}
void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@@ -310,7 +319,7 @@ void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@@ -318,7 +327,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, RedPipeItem *pos)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_after(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item, pos);
@@ -334,8 +343,8 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
agent->stream = &display->streams_buf[i];
region_init(&agent->vis_region);
region_init(&agent->clip);
- red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
- red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
+ red_pipe_item_init(&agent->create_item, RED_PIPE_ITEM_TYPE_STREAM_CREATE);
+ red_pipe_item_init(&agent->destroy_item, RED_PIPE_ITEM_TYPE_STREAM_DESTROY);
}
dcc->use_mjpeg_encoder_rate_control =
red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
@@ -445,7 +454,7 @@ void dcc_start(DisplayChannelClient *dcc)
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
if (display->surfaces[0].context.canvas) {
display_channel_current_flush(display, 0);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
dcc_create_surface(dcc, 0);
dcc_push_surface_image(dcc, 0);
dcc_push_monitors_config(dcc);
@@ -495,7 +504,7 @@ void dcc_stop(DisplayChannelClient *dcc)
void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
{
- StreamClipItem *item = stream_clip_item_new(agent);
+ RedStreamClipItem *item = red_stream_clip_item_new(agent);
int n_rects;
item->clip_type = SPICE_CLIP_TYPE_RECTS;
@@ -508,22 +517,22 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem *)item);
}
-static void monitors_config_item_free(MonitorsConfigItem *item)
+static void red_monitors_config_item_free(RedMonitorsConfigItem *item)
{
monitors_config_unref(item->monitors_config);
free(item);
}
-static MonitorsConfigItem *monitors_config_item_new(RedChannel* channel,
- MonitorsConfig *monitors_config)
+static RedMonitorsConfigItem *red_monitors_config_item_new(RedChannel* channel,
+ MonitorsConfig *monitors_config)
{
- MonitorsConfigItem *mci;
+ RedMonitorsConfigItem *mci;
- mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
+ mci = (RedMonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci->monitors_config = monitors_config;
- red_pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
- (GDestroyNotify)monitors_config_item_free);
+ red_pipe_item_init_full(&mci->pipe_item, RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
+ (GDestroyNotify)red_monitors_config_item_free);
return mci;
}
@@ -531,7 +540,7 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
{
DisplayChannel *dc = DCC_TO_DC(dcc);
MonitorsConfig *monitors_config = dc->monitors_config;
- MonitorsConfigItem *mci;
+ RedMonitorsConfigItem *mci;
if (monitors_config == NULL) {
spice_warning("monitors_config is NULL");
@@ -543,27 +552,27 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
return;
}
- mci = monitors_config_item_new(dcc->common.base.channel,
- monitors_config_ref(dc->monitors_config));
+ mci = red_monitors_config_item_new(dcc->common.base.channel,
+ monitors_config_ref(dc->monitors_config));
red_channel_client_pipe_add(&dcc->common.base, &mci->pipe_item);
red_channel_client_push(&dcc->common.base);
}
-static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel,
- uint32_t surface_id)
+static RedSurfaceDestroyItem *red_surface_destroy_item_new(RedChannel *channel,
+ uint32_t surface_id)
{
- SurfaceDestroyItem *destroy;
+ RedSurfaceDestroyItem *destroy;
- destroy = spice_malloc(sizeof(SurfaceDestroyItem));
+ destroy = spice_malloc(sizeof(RedSurfaceDestroyItem));
destroy->surface_destroy.surface_id = surface_id;
- red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
+ red_pipe_item_init(&destroy->pipe_item, RED_PIPE_ITEM_TYPE_DESTROY_SURFACE);
return destroy;
}
RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
{
- GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
+ RedGlScanoutUnixItem *item = spice_new(RedGlScanoutUnixItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
/* FIXME: on !unix peer, start streaming with a video codec */
@@ -574,7 +583,7 @@ RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
return NULL;
}
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_SCANOUT);
return &item->base;
}
@@ -583,7 +592,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
const SpiceMsgDisplayGlDraw *draw = data;
- GlDrawItem *item = spice_new(GlDrawItem, 1);
+ RedGlDrawItem *item = spice_new(RedGlDrawItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
if (!red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) {
@@ -594,7 +603,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
dcc->gl_draw_ongoing = TRUE;
item->draw = *draw;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_DRAW);
return &item->base;
}
@@ -603,7 +612,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
{
DisplayChannel *display;
RedChannel *channel;
- SurfaceDestroyItem *destroy;
+ RedSurfaceDestroyItem *destroy;
if (!dcc) {
return;
@@ -618,7 +627,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
}
dcc->surface_client_created[surface_id] = FALSE;
- destroy = surface_destroy_item_new(channel, surface_id);
+ destroy = red_surface_destroy_item_new(channel, surface_id);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy->pipe_item);
}
@@ -1300,7 +1309,7 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
if (cache->generation != dcc->pixmap_cache_generation) {
if (!dcc->pending_pixmaps_sync) {
red_channel_client_pipe_add_type(
- RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_SYNC);
+ RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_SYNC);
dcc->pending_pixmaps_sync = TRUE;
}
free(item);
@@ -1552,9 +1561,9 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
if (migrate_data->pixmap_cache_freezer) {
/* activating the cache. The cache will start to be active after
- * pixmap_cache_reset is called, when handling PIPE_ITEM_TYPE_PIXMAP_RESET */
+ * pixmap_cache_reset is called, when handling RED_PIPE_ITEM_TYPE_PIXMAP_RESET */
dcc->pixmap_cache->size = migrate_data->pixmap_cache_size;
- red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_RESET);
+ red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_RESET);
}
if (dcc_handle_migrate_glz_dictionary(dcc, migrate_data)) {
@@ -1583,7 +1592,7 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
spice_return_val_if_fail(surfaces_restored, FALSE);
- red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
/* enable sending messages */
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
return TRUE;
@@ -1592,16 +1601,16 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
static void release_item_after_push(RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_MONITORS_CONFIG:
- case PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_DRAW:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
red_pipe_item_unref(item);
break;
- case PIPE_ITEM_TYPE_GL_SCANOUT:
- case PIPE_ITEM_TYPE_GL_DRAW:
- case PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_VERB:
free(item);
break;
default:
@@ -1617,49 +1626,49 @@ static void release_item_before_push(DisplayChannelClient *dcc, RedPipeItem *ite
spice_debug("item.type: %d", item->type);
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW: {
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ case RED_PIPE_ITEM_TYPE_DRAW: {
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
ring_remove(&dpi->base);
red_pipe_item_unref(item);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CREATE: {
+ case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, create_item);
stream_agent_unref(display, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_DESTROY: {
+ case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, destroy_item);
stream_agent_unref(display, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_UPGRADE:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_MONITORS_CONFIG:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
red_pipe_item_unref(item);
break;
- case PIPE_ITEM_TYPE_CREATE_SURFACE: {
- SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, SurfaceCreateItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
+ RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, RedSurfaceCreateItem,
+ pipe_item);
free(surface_create);
break;
}
- case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
- SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, SurfaceDestroyItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
+ RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, RedSurfaceDestroyItem,
+ pipe_item);
free(surface_destroy);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- case PIPE_ITEM_TYPE_VERB:
- case PIPE_ITEM_TYPE_MIGRATE_DATA:
- case PIPE_ITEM_TYPE_PIXMAP_SYNC:
- case PIPE_ITEM_TYPE_PIXMAP_RESET:
- case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
- case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
- case PIPE_ITEM_TYPE_GL_SCANOUT:
- case PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ case RED_PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
+ case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
+ case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
free(item);
break;
default:
diff --git a/server/dcc.h b/server/dcc.h
index 52cd22a..509a6c6 100644
--- a/server/dcc.h
+++ b/server/dcc.h
@@ -82,7 +82,7 @@ struct DisplayChannelClient {
uint32_t pixmap_cache_generation;
int pending_pixmaps_sync;
- CacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
+ RedCacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
Ring palette_cache_lru;
long palette_cache_available;
uint32_t palette_cache_items;
@@ -121,21 +121,21 @@ struct DisplayChannelClient {
SPICE_CONTAINEROF((dcc)->common.base.channel, DisplayChannel, common.base)
#define RCC_TO_DCC(rcc) SPICE_CONTAINEROF((rcc), DisplayChannelClient, common.base)
-typedef struct SurfaceCreateItem {
+typedef struct RedSurfaceCreateItem {
SpiceMsgSurfaceCreate surface_create;
RedPipeItem pipe_item;
-} SurfaceCreateItem;
+} RedSurfaceCreateItem;
-typedef struct GlScanoutUnixItem {
+typedef struct RedGlScanoutUnixItem {
RedPipeItem base;
-} GlScanoutUnixItem;
+} RedGlScanoutUnixItem;
-typedef struct GlDrawItem {
+typedef struct RedGlDrawItem {
RedPipeItem base;
SpiceMsgDisplayGlDraw draw;
-} GlDrawItem;
+} RedGlDrawItem;
-typedef struct ImageItem {
+typedef struct RedImageItem {
RedPipeItem base;
SpicePoint pos;
int width;
@@ -147,15 +147,15 @@ typedef struct ImageItem {
uint32_t image_flags;
int can_lossy;
uint8_t data[0];
-} ImageItem;
+} RedImageItem;
-typedef struct DrawablePipeItem {
+typedef struct RedDrawablePipeItem {
RingItem base; /* link for a list of pipe items held by Drawable */
RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
Drawable *drawable;
DisplayChannelClient *dcc;
uint8_t refs;
-} DrawablePipeItem;
+} RedDrawablePipeItem;
DisplayChannelClient* dcc_new (DisplayChannel *display,
RedClient *client,
@@ -186,7 +186,7 @@ void dcc_create_surface (DisplayCha
int surface_id);
void dcc_push_surface_image (DisplayChannelClient *dcc,
int surface_id);
-ImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
+RedImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
RedPipeItem *pos,
diff --git a/server/display-channel.c b/server/display-channel.c
index 5dc593c..1f4d66f 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -337,7 +337,7 @@ static void pipes_add_drawable(DisplayChannel *display, Drawable *drawable)
static void pipes_add_drawable_after(DisplayChannel *display,
Drawable *drawable, Drawable *pos_after)
{
- DrawablePipeItem *dpi_pos_after;
+ RedDrawablePipeItem *dpi_pos_after;
RingItem *dpi_link, *dpi_next;
DisplayChannelClient *dcc;
int num_other_linked = 0;
@@ -396,11 +396,11 @@ static void current_remove_drawable(DisplayChannel *display, Drawable *item)
static void drawable_remove_from_pipes(Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *item, *next;
RING_FOREACH_SAFE(item, next, &drawable->pipes) {
- dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
+ dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, base);
if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi->dcc),
&dpi->dpi_pipe_item);
@@ -497,7 +497,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
if (is_same_drawable(drawable, other_drawable)) {
DisplayChannelClient *dcc;
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *worker_ring_item, *dpi_ring_item;
other_drawable->refs++;
@@ -511,7 +511,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
while (worker_ring_item) {
dcc = SPICE_CONTAINEROF(worker_ring_item, DisplayChannelClient,
common.base.channel_link);
- dpi = SPICE_CONTAINEROF(dpi_ring_item, DrawablePipeItem, base);
+ dpi = SPICE_CONTAINEROF(dpi_ring_item, RedDrawablePipeItem, base);
while (worker_ring_item && (!dpi || dcc != dpi->dcc)) {
dcc_prepend_drawable(dcc, drawable);
worker_ring_item = ring_next(&RED_CHANNEL(display)->clients,
@@ -1847,7 +1847,7 @@ void display_channel_destroy_surfaces(DisplayChannel *display)
spice_warn_if_fail(ring_is_empty(&display->streams));
if (red_channel_is_connected(RED_CHANNEL(display))) {
- red_channel_pipes_add_type(RED_CHANNEL(display), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_pipes_add_type(RED_CHANNEL(display), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_pipes_add_verb(RED_CHANNEL(display), SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL);
}
@@ -1968,10 +1968,10 @@ static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
spice_return_if_fail(item);
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_DRAW:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
red_pipe_item_ref(item);
break;
default:
@@ -1992,7 +1992,7 @@ static int handle_migrate_flush_mark(RedChannelClient *rcc)
DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base);
RedChannel *channel = RED_CHANNEL(display_channel);
- red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_MIGRATE_DATA);
+ red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_MIGRATE_DATA);
return TRUE;
}
diff --git a/server/display-channel.h b/server/display-channel.h
index bf2e4f0..84ec8ab 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -84,7 +84,7 @@ struct Drawable {
void drawable_unref (Drawable *drawable);
-#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), DrawablePipeItem, base)
+#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), RedDrawablePipeItem, base)
#define DRAWABLE_FOREACH_DPI_SAFE(drawable, link, next, dpi) \
SAFE_FOREACH(link, next, drawable, &(drawable)->pipes, dpi, LINK_TO_DPI(link))
@@ -94,22 +94,22 @@ void drawable_unref (Drawable *drawable);
SAFE_FOREACH(link, next, drawable, &(drawable)->glz_ring, glz, LINK_TO_GLZ(link))
enum {
- PIPE_ITEM_TYPE_DRAW = PIPE_ITEM_TYPE_COMMON_LAST,
- PIPE_ITEM_TYPE_IMAGE,
- PIPE_ITEM_TYPE_STREAM_CREATE,
- PIPE_ITEM_TYPE_STREAM_CLIP,
- PIPE_ITEM_TYPE_STREAM_DESTROY,
- PIPE_ITEM_TYPE_UPGRADE,
- PIPE_ITEM_TYPE_MIGRATE_DATA,
- PIPE_ITEM_TYPE_PIXMAP_SYNC,
- PIPE_ITEM_TYPE_PIXMAP_RESET,
- PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
- PIPE_ITEM_TYPE_CREATE_SURFACE,
- PIPE_ITEM_TYPE_DESTROY_SURFACE,
- PIPE_ITEM_TYPE_MONITORS_CONFIG,
- PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
- PIPE_ITEM_TYPE_GL_SCANOUT,
- PIPE_ITEM_TYPE_GL_DRAW,
+ RED_PIPE_ITEM_TYPE_DRAW = RED_PIPE_ITEM_TYPE_COMMON_LAST,
+ RED_PIPE_ITEM_TYPE_IMAGE,
+ RED_PIPE_ITEM_TYPE_STREAM_CREATE,
+ RED_PIPE_ITEM_TYPE_STREAM_CLIP,
+ RED_PIPE_ITEM_TYPE_STREAM_DESTROY,
+ RED_PIPE_ITEM_TYPE_UPGRADE,
+ RED_PIPE_ITEM_TYPE_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_PIXMAP_SYNC,
+ RED_PIPE_ITEM_TYPE_PIXMAP_RESET,
+ RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
+ RED_PIPE_ITEM_TYPE_CREATE_SURFACE,
+ RED_PIPE_ITEM_TYPE_DESTROY_SURFACE,
+ RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
+ RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
+ RED_PIPE_ITEM_TYPE_GL_SCANOUT,
+ RED_PIPE_ITEM_TYPE_GL_DRAW,
};
typedef struct MonitorsConfig {
@@ -119,10 +119,10 @@ typedef struct MonitorsConfig {
QXLHead heads[0];
} MonitorsConfig;
-typedef struct MonitorsConfigItem {
+typedef struct RedMonitorsConfigItem {
RedPipeItem pipe_item;
MonitorsConfig *monitors_config;
-} MonitorsConfigItem;
+} RedMonitorsConfigItem;
MonitorsConfig* monitors_config_new (QXLHead *heads, ssize_t nheads,
ssize_t max);
@@ -240,16 +240,16 @@ static inline int get_stream_id(DisplayChannel *display, Stream *stream)
return (int)(stream - display->streams_buf);
}
-typedef struct SurfaceDestroyItem {
+typedef struct RedSurfaceDestroyItem {
SpiceMsgSurfaceDestroy surface_destroy;
RedPipeItem pipe_item;
-} SurfaceDestroyItem;
+} RedSurfaceDestroyItem;
-typedef struct UpgradeItem {
+typedef struct RedUpgradeItem {
RedPipeItem base;
Drawable *drawable;
SpiceClipRects *rects;
-} UpgradeItem;
+} RedUpgradeItem;
DisplayChannel* display_channel_new (SpiceServer *reds,
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 81a8d4a..d1af9cf 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -116,25 +116,25 @@ struct InputsChannel {
};
enum {
- PIPE_ITEM_INPUTS_INIT = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_MOUSE_MOTION_ACK,
- PIPE_ITEM_KEY_MODIFIERS,
- PIPE_ITEM_MIGRATE_DATA,
+ RED_PIPE_ITEM_INPUTS_INIT = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_MOUSE_MOTION_ACK,
+ RED_PIPE_ITEM_KEY_MODIFIERS,
+ RED_PIPE_ITEM_MIGRATE_DATA,
};
-typedef struct InputsPipeItem {
+typedef struct RedInputsPipeItem {
RedPipeItem base;
-} InputsPipeItem;
+} RedInputsPipeItem;
-typedef struct KeyModifiersPipeItem {
+typedef struct RedKeyModifiersPipeItem {
RedPipeItem base;
uint8_t modifiers;
-} KeyModifiersPipeItem;
+} RedKeyModifiersPipeItem;
-typedef struct InputsInitPipeItem {
+typedef struct RedInputsInitPipeItem {
RedPipeItem base;
uint8_t modifiers;
-} InputsInitPipeItem;
+} RedInputsInitPipeItem;
static SpiceTimer *key_modifiers_timer;
@@ -229,12 +229,12 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
return sif->get_leds(sin);
}
-static RedPipeItem *inputs_key_modifiers_item_new(
+static RedPipeItem *red_inputs_key_modifiers_item_new(
RedChannelClient *rcc, void *data, int num)
{
- KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
+ RedKeyModifiersPipeItem *item = spice_malloc(sizeof(RedKeyModifiersPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_KEY_MODIFIERS);
item->modifiers = *(uint8_t *)data;
return &item->base;
}
@@ -265,30 +265,30 @@ static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (base->type) {
- case PIPE_ITEM_KEY_MODIFIERS:
+ case RED_PIPE_ITEM_KEY_MODIFIERS:
{
SpiceMsgInputsKeyModifiers key_modifiers;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_KEY_MODIFIERS, base);
key_modifiers.modifiers =
- SPICE_CONTAINEROF(base, KeyModifiersPipeItem, base)->modifiers;
+ SPICE_CONTAINEROF(base, RedKeyModifiersPipeItem, base)->modifiers;
spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
break;
}
- case PIPE_ITEM_INPUTS_INIT:
+ case RED_PIPE_ITEM_INPUTS_INIT:
{
SpiceMsgInputsInit inputs_init;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_INIT, base);
inputs_init.keyboard_modifiers =
- SPICE_CONTAINEROF(base, InputsInitPipeItem, base)->modifiers;
+ SPICE_CONTAINEROF(base, RedInputsInitPipeItem, base)->modifiers;
spice_marshall_msg_inputs_init(m, &inputs_init);
break;
}
- case PIPE_ITEM_MOUSE_MOTION_ACK:
+ case RED_PIPE_ITEM_MOUSE_MOTION_ACK:
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, base);
break;
- case PIPE_ITEM_MIGRATE_DATA:
+ case RED_PIPE_ITEM_MIGRATE_DATA:
inputs_channel_send_migrate_data(rcc, m, base);
break;
default:
@@ -339,7 +339,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (mouse && reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_SERVER) {
@@ -357,7 +357,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT) {
@@ -500,10 +500,10 @@ static void inputs_channel_on_disconnect(RedChannelClient *rcc)
static void inputs_pipe_add_init(RedChannelClient *rcc)
{
- InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
+ RedInputsInitPipeItem *item = spice_malloc(sizeof(RedInputsInitPipeItem));
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
- red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_INPUTS_INIT);
item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -569,7 +569,7 @@ static void inputs_channel_push_keyboard_modifiers(InputsChannel *inputs, uint8_
return;
}
red_channel_pipes_new_add_push(&inputs->base,
- inputs_key_modifiers_item_new, (void*)&modifiers);
+ red_inputs_key_modifiers_item_new, (void*)&modifiers);
}
void inputs_channel_on_keyboard_leds_change(InputsChannel *inputs, uint8_t leds)
@@ -585,7 +585,7 @@ static void key_modifiers_sender(void *opaque)
static int inputs_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MIGRATE_DATA);
return TRUE;
}
@@ -612,7 +612,7 @@ static int inputs_channel_handle_migrate_data(RedChannelClient *rcc,
for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
}
return TRUE;
}
diff --git a/server/main-channel.c b/server/main-channel.c
index b904e33..33f8eed 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -60,54 +60,54 @@
static const uint8_t zero_page[ZERO_BUF_SIZE] = {0};
enum {
- PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_MAIN_PING,
- PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
- PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
- PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
- PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
- PIPE_ITEM_TYPE_MAIN_INIT,
- PIPE_ITEM_TYPE_MAIN_NOTIFY,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
- PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
- PIPE_ITEM_TYPE_MAIN_NAME,
- PIPE_ITEM_TYPE_MAIN_UUID,
- PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
+ RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_MAIN_PING,
+ RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_MAIN_INIT,
+ RED_PIPE_ITEM_TYPE_MAIN_NOTIFY,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
+ RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
+ RED_PIPE_ITEM_TYPE_MAIN_NAME,
+ RED_PIPE_ITEM_TYPE_MAIN_UUID,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
};
-typedef struct RefsPipeItem {
+typedef struct RedRefsPipeItem {
RedPipeItem base;
int *refs;
-} RefsPipeItem;
+} RedRefsPipeItem;
-typedef struct PingPipeItem {
+typedef struct RedPingPipeItem {
RedPipeItem base;
int size;
-} PingPipeItem;
+} RedPingPipeItem;
-typedef struct MouseModePipeItem {
+typedef struct RedMouseModePipeItem {
RedPipeItem base;
int current_mode;
int is_client_mouse_allowed;
-} MouseModePipeItem;
+} RedMouseModePipeItem;
-typedef struct TokensPipeItem {
+typedef struct RedTokensPipeItem {
RedPipeItem base;
int tokens;
-} TokensPipeItem;
+} RedTokensPipeItem;
-typedef struct AgentDataPipeItem {
+typedef struct RedAgentDataPipeItem {
RedPipeItem base;
uint8_t* data;
size_t len;
spice_marshaller_item_free_func free_data;
void *opaque;
-} AgentDataPipeItem;
+} RedAgentDataPipeItem;
-typedef struct InitPipeItem {
+typedef struct RedInitPipeItem {
RedPipeItem base;
int connection_id;
int display_channels_hint;
@@ -115,27 +115,27 @@ typedef struct InitPipeItem {
int is_client_mouse_allowed;
int multi_media_time;
int ram_hint;
-} InitPipeItem;
+} RedInitPipeItem;
-typedef struct NamePipeItem {
+typedef struct RedNamePipeItem {
RedPipeItem base;
SpiceMsgMainName msg;
-} NamePipeItem;
+} RedNamePipeItem;
-typedef struct UuidPipeItem {
+typedef struct RedUuidPipeItem {
RedPipeItem base;
SpiceMsgMainUuid msg;
-} UuidPipeItem;
+} RedUuidPipeItem;
-typedef struct NotifyPipeItem {
+typedef struct RedNotifyPipeItem {
RedPipeItem base;
char *msg;
-} NotifyPipeItem;
+} RedNotifyPipeItem;
-typedef struct MultiMediaTimePipeItem {
+typedef struct RedMultiMediaTimePipeItem {
RedPipeItem base;
int time;
-} MultiMediaTimePipeItem;
+} RedMultiMediaTimePipeItem;
struct MainChannelClient {
RedChannelClient base;
@@ -223,29 +223,29 @@ typedef struct MainMouseModeItemInfo {
static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
{
- MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
+ RedMouseModePipeItem *item = spice_malloc(sizeof(RedMouseModePipeItem));
MainMouseModeItemInfo *info = data;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
item->current_mode = info->current_mode;
item->is_client_mouse_allowed = info->is_client_mouse_allowed;
return &item->base;
}
-static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
+static RedPipeItem *red_ping_item_new(MainChannelClient *mcc, int size)
{
- PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
+ RedPingPipeItem *item = spice_malloc(sizeof(RedPingPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_PING);
item->size = size;
return &item->base;
}
static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
{
- TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
+ RedTokensPipeItem *item = spice_malloc(sizeof(RedTokensPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
item->tokens = num_tokens;
return &item->base;
}
@@ -254,9 +254,9 @@ static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* dat
spice_marshaller_item_free_func free_data,
void *opaque)
{
- AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
+ RedAgentDataPipeItem *item = spice_malloc(sizeof(RedAgentDataPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
item->data = data;
item->len = len;
item->free_data = free_data;
@@ -269,9 +269,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
- InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
+ RedInitPipeItem *item = spice_malloc(sizeof(RedInitPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_INIT);
item->connection_id = connection_id;
item->display_channels_hint = display_channels_hint;
item->current_mouse_mode = current_mouse_mode;
@@ -283,9 +283,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
{
- NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
+ RedNamePipeItem *item = spice_malloc(sizeof(RedNamePipeItem) + strlen(name) + 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NAME);
item->msg.name_len = strlen(name) + 1;
memcpy(&item->msg.name, name, item->msg.name_len);
@@ -294,9 +294,9 @@ static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
{
- UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
+ RedUuidPipeItem *item = spice_malloc(sizeof(RedUuidPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_UUID);
memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
return &item->base;
@@ -304,10 +304,10 @@ static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uui
static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
{
- NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
+ RedNotifyPipeItem *item = spice_malloc(sizeof(RedNotifyPipeItem));
const char *msg = data;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NOTIFY);
item->msg = spice_strdup(msg);
return &item->base;
}
@@ -315,10 +315,10 @@ static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int
static RedPipeItem *main_multi_media_time_item_new(
RedChannelClient *rcc, void *data, int num)
{
- MultiMediaTimePipeItem *item, *info = data;
+ RedMultiMediaTimePipeItem *item, *info = data;
- item = spice_malloc(sizeof(MultiMediaTimePipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
+ item = spice_malloc(sizeof(RedMultiMediaTimePipeItem));
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item->time = info->time;
return &item->base;
}
@@ -330,7 +330,7 @@ static void main_channel_push_channels(MainChannelClient *mcc)
"during migration");
return;
}
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
}
static void main_channel_marshall_channels(RedChannelClient *rcc,
@@ -354,14 +354,14 @@ int main_channel_client_push_ping(MainChannelClient *mcc, int size)
if (mcc == NULL) {
return FALSE;
}
- item = main_ping_item_new(mcc, size);
+ item = red_ping_item_new(mcc, size);
red_channel_client_pipe_add_push(&mcc->base, item);
return TRUE;
}
static void main_channel_marshall_ping(RedChannelClient *rcc,
SpiceMarshaller *m,
- PingPipeItem *item)
+ RedPingPipeItem *item)
{
MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
SpiceMsgPing ping;
@@ -393,7 +393,7 @@ void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
SpiceMarshaller *m,
- MouseModePipeItem *item)
+ RedMouseModePipeItem *item)
{
SpiceMsgMainMouseMode mouse_mode;
@@ -409,7 +409,7 @@ static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
void main_channel_push_agent_connected(MainChannel *main_chan)
{
if (red_channel_test_remote_cap(&main_chan->base, SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
} else {
red_channel_pipes_add_empty_msg(&main_chan->base, SPICE_MSG_MAIN_AGENT_CONNECTED);
}
@@ -428,7 +428,7 @@ static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
void main_channel_push_agent_disconnected(MainChannel *main_chan)
{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
}
static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
@@ -450,7 +450,7 @@ void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_
}
static void main_channel_marshall_tokens(RedChannelClient *rcc,
- SpiceMarshaller *m, TokensPipeItem *item)
+ SpiceMarshaller *m, RedTokensPipeItem *item)
{
SpiceMsgMainAgentTokens tokens;
@@ -470,7 +470,7 @@ void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data,
static void main_channel_marshall_agent_data(RedChannelClient *rcc,
SpiceMarshaller *m,
- AgentDataPipeItem *item)
+ RedAgentDataPipeItem *item)
{
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DATA, &item->base);
spice_marshaller_add_ref(m, item->data, item->len);
@@ -478,7 +478,7 @@ static void main_channel_marshall_agent_data(RedChannelClient *rcc,
static void main_channel_push_migrate_data_item(MainChannel *main_chan)
{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
}
static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
@@ -526,9 +526,9 @@ void main_channel_push_init(MainChannelClient *mcc,
static void main_channel_marshall_init(RedChannelClient *rcc,
SpiceMarshaller *m,
- InitPipeItem *item)
+ RedInitPipeItem *item)
{
- SpiceMsgMainInit init; // TODO - remove this copy, make InitPipeItem reuse SpiceMsgMainInit
+ SpiceMsgMainInit init; // TODO - remove this copy, make RedInitPipeItem reuse SpiceMsgMainInit
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_INIT, &item->base);
@@ -577,7 +577,7 @@ void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
}
static void main_channel_marshall_notify(RedChannelClient *rcc,
- SpiceMarshaller *m, NotifyPipeItem *item)
+ SpiceMarshaller *m, RedNotifyPipeItem *item)
{
SpiceMsgNotify notify;
@@ -636,7 +636,7 @@ static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
{
- MultiMediaTimePipeItem info = {
+ RedMultiMediaTimePipeItem info = {
.time = time,
};
@@ -662,7 +662,7 @@ static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice
void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target)
{
main_channel_fill_mig_target(main_chan, mig_target);
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
@@ -690,7 +690,7 @@ static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelC
static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
SpiceMarshaller *m,
- MultiMediaTimePipeItem *item)
+ RedMultiMediaTimePipeItem *item)
{
SpiceMsgMainMultiMediaTime time_mes;
@@ -708,7 +708,7 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
* we ignore any pipe item that arrives before the INIT msg is sent.
* For seamless we don't send INIT, and the connection continues from the same place
* it stopped on the src side. */
- if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != PIPE_ITEM_TYPE_MAIN_INIT) {
+ if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != RED_PIPE_ITEM_TYPE_MAIN_INIT) {
spice_printerr("Init msg for client %p was not sent yet "
"(client is probably during semi-seamless migration). Ignoring msg type %d",
rcc->client, base->type);
@@ -716,65 +716,65 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
return;
}
switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
+ case RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
main_channel_marshall_channels(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_PING:
+ case RED_PIPE_ITEM_TYPE_MAIN_PING:
main_channel_marshall_ping(rcc, m,
- SPICE_CONTAINEROF(base, PingPipeItem, base));
+ SPICE_CONTAINEROF(base, RedPingPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
+ case RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
{
- MouseModePipeItem *item =
- SPICE_CONTAINEROF(base, MouseModePipeItem, base);
+ RedMouseModePipeItem *item =
+ SPICE_CONTAINEROF(base, RedMouseModePipeItem, base);
main_channel_marshall_mouse_mode(rcc, m, item);
break;
}
- case PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
main_channel_marshall_agent_disconnected(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
main_channel_marshall_tokens(rcc, m,
- SPICE_CONTAINEROF(base, TokensPipeItem, base));
+ SPICE_CONTAINEROF(base, RedTokensPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
main_channel_marshall_agent_data(rcc, m,
- SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
+ SPICE_CONTAINEROF(base, RedAgentDataPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
main_channel_marshall_migrate_data_item(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_INIT:
+ case RED_PIPE_ITEM_TYPE_MAIN_INIT:
mcc->init_sent = TRUE;
main_channel_marshall_init(rcc, m,
- SPICE_CONTAINEROF(base, InitPipeItem, base));
+ SPICE_CONTAINEROF(base, RedInitPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_NOTIFY:
+ case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY:
main_channel_marshall_notify(rcc, m,
- SPICE_CONTAINEROF(base, NotifyPipeItem, base));
+ SPICE_CONTAINEROF(base, RedNotifyPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
main_channel_marshall_migrate_begin(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
main_channel_marshall_migrate_begin_seamless(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
+ case RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
main_channel_marshall_multi_media_time(rcc, m,
- SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
+ SPICE_CONTAINEROF(base, RedMultiMediaTimePipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
main_channel_marshall_migrate_switch(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_NAME:
+ case RED_PIPE_ITEM_TYPE_MAIN_NAME:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_NAME, base);
- spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, NamePipeItem, base)->msg);
+ spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, RedNamePipeItem, base)->msg);
break;
- case PIPE_ITEM_TYPE_MAIN_UUID:
+ case RED_PIPE_ITEM_TYPE_MAIN_UUID:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_UUID, base);
- spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, UuidPipeItem, base)->msg);
+ spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, RedUuidPipeItem, base)->msg);
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
main_channel_marshall_agent_connected(m, rcc, base);
break;
default:
@@ -787,14 +787,14 @@ static void main_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *base, int item_pushed)
{
switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
- AgentDataPipeItem *data = (AgentDataPipeItem *)base;
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
+ RedAgentDataPipeItem *data = (RedAgentDataPipeItem *)base;
data->free_data(data->data, data->opaque);
break;
}
- case PIPE_ITEM_TYPE_MAIN_NOTIFY: {
- NotifyPipeItem *data = (NotifyPipeItem *)base;
+ case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY: {
+ RedNotifyPipeItem *data = (RedNotifyPipeItem *)base;
free(data->msg);
break;
}
@@ -861,9 +861,9 @@ void main_channel_migrate_dst_complete(MainChannelClient *mcc)
if (mcc->mig_wait_prev_try_seamless) {
spice_assert(mcc->base.channel->clients_num == 1);
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
} else {
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
}
mcc->mig_wait_connect = TRUE;
mcc->mig_wait_prev_complete = FALSE;
@@ -1211,7 +1211,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = FALSE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@@ -1238,7 +1238,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = TRUE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@@ -1325,7 +1325,7 @@ int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
} else {
if (success) {
spice_printerr("client %p SWITCH_HOST", mcc->base.client);
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
}
mcc->mig_connect_ok = FALSE;
diff --git a/server/red-channel.c b/server/red-channel.c
index 834ddb7..d9aab01 100644
--- a/server/red-channel.c
+++ b/server/red-channel.c
@@ -44,10 +44,10 @@
#include "main-dispatcher.h"
#include "utils.h"
-typedef struct EmptyMsgPipeItem {
+typedef struct RedEmptyMsgPipeItem {
RedPipeItem base;
int msg;
-} EmptyMsgPipeItem;
+} RedEmptyMsgPipeItem;
#define PING_TEST_TIMEOUT_MS (MSEC_PER_SEC * 15)
#define PING_TEST_IDLE_NET_TIMEOUT_MS (MSEC_PER_SEC / 10)
@@ -477,7 +477,7 @@ static void red_channel_client_reset_send_data(RedChannelClient *rcc)
void red_channel_client_push_set_ack(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SET_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SET_ACK);
}
static void red_channel_client_send_set_ack(RedChannelClient *rcc)
@@ -512,7 +512,7 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc)
static void red_channel_client_send_empty_msg(RedChannelClient *rcc, RedPipeItem *base)
{
- EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, EmptyMsgPipeItem, base);
+ RedEmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, RedEmptyMsgPipeItem, base);
red_channel_client_init_send_data(rcc, msg_pipe_item->msg, NULL);
red_channel_client_begin_send_message(rcc);
@@ -562,16 +562,16 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
spice_assert(red_channel_client_no_item_being_sent(rcc));
red_channel_client_reset_send_data(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_SET_ACK:
+ case RED_PIPE_ITEM_TYPE_SET_ACK:
red_channel_client_send_set_ack(rcc);
break;
- case PIPE_ITEM_TYPE_MIGRATE:
+ case RED_PIPE_ITEM_TYPE_MIGRATE:
red_channel_client_send_migrate(rcc);
break;
- case PIPE_ITEM_TYPE_EMPTY_MSG:
+ case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
red_channel_client_send_empty_msg(rcc, item);
break;
- case PIPE_ITEM_TYPE_PING:
+ case RED_PIPE_ITEM_TYPE_PING:
red_channel_client_send_ping(rcc);
break;
default:
@@ -584,10 +584,10 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
static void red_channel_client_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_SET_ACK:
- case PIPE_ITEM_TYPE_EMPTY_MSG:
- case PIPE_ITEM_TYPE_MIGRATE:
- case PIPE_ITEM_TYPE_PING:
+ case RED_PIPE_ITEM_TYPE_SET_ACK:
+ case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
+ case RED_PIPE_ITEM_TYPE_MIGRATE:
+ case RED_PIPE_ITEM_TYPE_PING:
free(item);
break;
default:
@@ -733,8 +733,8 @@ static void red_channel_client_push_ping(RedChannelClient *rcc)
rcc->latency_monitor.state = PING_STATE_WARMUP;
rcc->latency_monitor.warmup_was_sent = FALSE;
rcc->latency_monitor.id = rand();
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
}
static void red_channel_client_ping_timer(void *opaque)
@@ -1013,7 +1013,7 @@ void red_channel_client_default_migrate(RedChannelClient *rcc)
rcc->channel->core->timer_remove(rcc->connectivity_monitor.timer);
rcc->connectivity_monitor.timer = NULL;
}
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MIGRATE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_MIGRATE);
}
RedChannel *red_channel_create(int size,
@@ -1737,9 +1737,9 @@ void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type)
void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
{
- EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
+ RedEmptyMsgPipeItem *item = spice_new(RedEmptyMsgPipeItem, 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_EMPTY_MSG);
item->msg = msg_type;
red_channel_client_pipe_add(rcc, &item->base);
red_channel_client_push(rcc);
diff --git a/server/red-channel.h b/server/red-channel.h
index be5ae99..d169a9a 100644
--- a/server/red-channel.h
+++ b/server/red-channel.h
@@ -140,12 +140,12 @@ typedef struct MainChannelClient MainChannelClient;
* but we keep the 100 first allocated for base channel approach.
* */
enum {
- PIPE_ITEM_TYPE_SET_ACK=1,
- PIPE_ITEM_TYPE_MIGRATE,
- PIPE_ITEM_TYPE_EMPTY_MSG,
- PIPE_ITEM_TYPE_PING,
+ RED_PIPE_ITEM_TYPE_SET_ACK=1,
+ RED_PIPE_ITEM_TYPE_MIGRATE,
+ RED_PIPE_ITEM_TYPE_EMPTY_MSG,
+ RED_PIPE_ITEM_TYPE_PING,
- PIPE_ITEM_TYPE_CHANNEL_BASE=101,
+ RED_PIPE_ITEM_TYPE_CHANNEL_BASE=101,
};
typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannelClient *channel,
diff --git a/server/red-worker.h b/server/red-worker.h
index 731afc7..d7525e0 100644
--- a/server/red-worker.h
+++ b/server/red-worker.h
@@ -50,27 +50,27 @@ typedef struct CommonGraphicsChannel {
#define COMMON_GRAPHICS_CHANNEL(Channel) ((CommonGraphicsChannel*)(Channel))
enum {
- PIPE_ITEM_TYPE_VERB = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_INVAL_ONE,
+ RED_PIPE_ITEM_TYPE_VERB = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_INVAL_ONE,
- PIPE_ITEM_TYPE_COMMON_LAST
+ RED_PIPE_ITEM_TYPE_COMMON_LAST
};
-typedef struct VerbItem {
+typedef struct RedVerbItem {
RedPipeItem base;
uint16_t verb;
-} VerbItem;
+} RedVerbItem;
-static inline void red_marshall_verb(RedChannelClient *rcc, VerbItem *item)
+static inline void red_marshall_verb(RedChannelClient *rcc, RedVerbItem *item)
{
red_channel_client_init_send_data(rcc, item->verb, NULL);
}
static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
{
- VerbItem *item = spice_new(VerbItem, 1);
+ RedVerbItem *item = spice_new(RedVerbItem, 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_VERB);
item->verb = verb;
red_channel_client_pipe_add(rcc, &item->base);
}
diff --git a/server/reds.c b/server/reds.c
index 51ee331..97c77f7 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -166,13 +166,13 @@ struct ChannelSecurityOptions {
ChannelSecurityOptions *next;
};
-typedef struct VDIReadBuf {
+typedef struct RedVDIReadBuf {
RedPipeItem parent;
RedCharDeviceVDIPort *dev;
int len;
uint8_t data[SPICE_AGENT_MAX_DATA_SIZE];
-} VDIReadBuf;
+} RedVDIReadBuf;
enum {
VDI_PORT_READ_STATE_READ_HEADER,
@@ -196,7 +196,7 @@ struct RedCharDeviceVDIPortPrivate {
uint32_t message_receive_len;
uint8_t *receive_pos;
uint32_t receive_len;
- VDIReadBuf *current_read_buf;
+ RedVDIReadBuf *current_read_buf;
AgentMsgFilter read_filter;
VDIChunkHeader vdi_chunk_header;
@@ -261,8 +261,8 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode);
static uint32_t reds_qxl_ram_size(RedsState *reds);
static int calc_compression_level(RedsState *reds);
-static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
-static void vdi_port_read_buf_free(VDIReadBuf *buf);
+static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
+static void vdi_port_read_buf_free(RedVDIReadBuf *buf);
static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int id)
{
@@ -703,13 +703,14 @@ static void reds_agent_remove(RedsState *reds)
static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
- VDIReadBuf *buf = (VDIReadBuf *)opaque;
+ RedVDIReadBuf *buf = (RedVDIReadBuf *)opaque;
red_pipe_item_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
-static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf *buf, gboolean *error)
+static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev,
+ RedVDIReadBuf *buf, gboolean *error)
{
int res;
@@ -738,7 +739,7 @@ static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf
}
}
-static void vdi_read_buf_init(VDIReadBuf *buf)
+static void vdi_read_buf_init(RedVDIReadBuf *buf)
{
g_return_if_fail(buf != NULL);
/* Bogus pipe item type, we only need the RingItem and refcounting
@@ -748,17 +749,17 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
(GDestroyNotify)vdi_port_read_buf_free);
}
-static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
+static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
{
RingItem *item;
- VDIReadBuf *buf;
+ RedVDIReadBuf *buf;
if (!(item = ring_get_head(&dev->priv->read_bufs))) {
return NULL;
}
ring_remove(item);
- buf = SPICE_CONTAINEROF(item, VDIReadBuf, parent.link);
+ buf = SPICE_CONTAINEROF(item, RedVDIReadBuf, parent.link);
g_warn_if_fail(buf->parent.refcount == 0);
vdi_read_buf_init(buf);
@@ -766,7 +767,7 @@ static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
return buf;
}
-static void vdi_port_read_buf_free(VDIReadBuf *buf)
+static void vdi_port_read_buf_free(RedVDIReadBuf *buf)
{
g_warn_if_fail(buf->parent.refcount == 0);
ring_add(&buf->dev->priv->read_bufs, (RingItem *)buf);
@@ -788,7 +789,7 @@ static RedPipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *s
RedsState *reds;
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
SpiceCharDeviceInterface *sif;
- VDIReadBuf *dispatch_buf;
+ RedVDIReadBuf *dispatch_buf;
int n;
g_object_get(dev, "spice-server", &reds, NULL);
@@ -861,7 +862,7 @@ static void vdi_port_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
- VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
+ RedVDIReadBuf *agent_data_buf = (RedVDIReadBuf *)msg;
red_pipe_item_ref(agent_data_buf);
main_channel_client_push_agent_data(red_client_get_main(client),
@@ -1201,7 +1202,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
if (agent_dev->priv->read_filter.msg_data_to_read ||
read_data_len > sizeof(VDAgentMessage)) { /* msg header has been read */
- VDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
+ RedVDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
gboolean error = FALSE;
spice_debug("push partial read %u (msg first chunk? %d)", read_data_len,
@@ -4290,7 +4291,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort *self)
self->priv->receive_len = sizeof(self->priv->vdi_chunk_header);
for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
- VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);
+ RedVDIReadBuf *buf = spice_new0(RedVDIReadBuf, 1);
vdi_read_buf_init(buf);
buf->dev = self;
g_warn_if_fail(!self->priv->agent_attached);
@@ -4307,7 +4308,7 @@ red_char_device_vdi_port_finalize(GObject *object)
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(object);
free(dev->priv->mig_data);
- /* FIXME: need to free the VDIReadBuf allocated previously */
+ /* FIXME: need to free the RedVDIReadBuf allocated previously */
}
static void
diff --git a/server/smartcard.c b/server/smartcard.c
index 75c5dd2..a42bcd8 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -77,24 +77,24 @@ struct RedCharDeviceSmartcardPrivate {
};
enum {
- PIPE_ITEM_TYPE_ERROR = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_SMARTCARD_DATA,
- PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_ERROR = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
+ RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
};
-typedef struct ErrorItem {
+typedef struct RedErrorItem {
RedPipeItem base;
VSCMsgHeader vheader;
VSCMsgError error;
-} ErrorItem;
+} RedErrorItem;
-typedef struct MsgItem {
+typedef struct RedMsgItem {
RedPipeItem base;
VSCMsgHeader* vheader;
-} MsgItem;
+} RedMsgItem;
-static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
+static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
typedef struct SmartCardChannel {
@@ -113,7 +113,7 @@ static void smartcard_char_device_attach_client(
SpiceCharDeviceInstance *char_device, SmartCardChannelClient *scc);
static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_buf);
-static MsgItem *smartcard_char_device_on_message_from_device(
+static RedMsgItem *smartcard_char_device_on_message_from_device(
RedCharDeviceSmartcard *dev, VSCMsgHeader *header);
static RedCharDeviceSmartcard *smartcard_device_new(RedsState *reds, SpiceCharDeviceInstance *sin);
static void smartcard_init(RedsState *reds);
@@ -140,7 +140,7 @@ static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
int actual_length;
while ((n = sif->read(sin, dev->priv->buf_pos, dev->priv->buf_size - dev->priv->buf_used)) > 0) {
- MsgItem *msg_to_client;
+ RedMsgItem *msg_to_client;
dev->priv->buf_pos += n;
dev->priv->buf_used += n;
@@ -190,8 +190,8 @@ static void smartcard_remove_client(RedClient *client, void *opaque)
red_channel_client_shutdown(&dev->priv->scc->base);
}
-MsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
- VSCMsgHeader *vheader)
+RedMsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
+ VSCMsgHeader *vheader)
{
VSCMsgHeader *sent_header;
@@ -441,7 +441,7 @@ static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *
static void smartcard_channel_send_error(
RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
{
- ErrorItem* error_item = (ErrorItem*)item;
+ RedErrorItem* error_item = (RedErrorItem*)item;
smartcard_channel_send_data(rcc, m, item, &error_item->vheader);
}
@@ -449,7 +449,7 @@ static void smartcard_channel_send_error(
static void smartcard_channel_send_msg(RedChannelClient *rcc,
SpiceMarshaller *m, RedPipeItem *item)
{
- MsgItem* msg_item = (MsgItem*)item;
+ RedMsgItem* msg_item = (RedMsgItem*)item;
smartcard_channel_send_data(rcc, m, item, msg_item->vheader);
}
@@ -488,13 +488,13 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_ERROR:
+ case RED_PIPE_ITEM_TYPE_ERROR:
smartcard_channel_send_error(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SMARTCARD_DATA:
+ case RED_PIPE_ITEM_TYPE_SMARTCARD_DATA:
smartcard_channel_send_msg(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
smartcard_channel_send_migrate_data(rcc, m, item);
break;
default:
@@ -508,7 +508,7 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item, int item_pushed)
{
- if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
+ if (item->type == RED_PIPE_ITEM_TYPE_SMARTCARD_DATA) {
red_pipe_item_unref(item);
} else {
free(item);
@@ -538,11 +538,11 @@ static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCErrorCode error)
{
- ErrorItem *error_item = spice_new0(ErrorItem, 1);
+ RedErrorItem *error_item = spice_new0(RedErrorItem, 1);
- red_pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
+ red_pipe_item_init(&error_item->base, RED_PIPE_ITEM_TYPE_ERROR);
- error_item->base.type = PIPE_ITEM_TYPE_ERROR;
+ error_item->base.type = RED_PIPE_ITEM_TYPE_ERROR;
error_item->vheader.reader_id = reader_id;
error_item->vheader.type = VSC_Error;
error_item->vheader.length = sizeof(error_item->error);
@@ -550,17 +550,18 @@ static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCE
smartcard_channel_client_pipe_add_push(rcc, &error_item->base);
}
-static void smartcard_free_vsc_msg_item(MsgItem *item)
+static void smartcard_free_vsc_msg_item(RedMsgItem *item)
{
free(item->vheader);
free(item);
}
-static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader)
+static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc,
+ VSCMsgHeader *vheader)
{
- MsgItem *msg_item = spice_new0(MsgItem, 1);
+ RedMsgItem *msg_item = spice_new0(RedMsgItem, 1);
- red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
+ red_pipe_item_init_full(&msg_item->base, RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
(GDestroyNotify)smartcard_free_vsc_msg_item);
msg_item->vheader = vheader;
return msg_item;
@@ -635,7 +636,7 @@ static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_bu
static int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
return TRUE;
}
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 8450f19..dffdd9a 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -42,20 +42,20 @@
/* 64K should be enough for all but the largest writes + 32 bytes hdr */
#define BUF_SIZE (64 * 1024 + 32)
-typedef struct SpiceVmcPipeItem {
+typedef struct RedVmcPipeItem {
RedPipeItem base;
/* writes which don't fit this will get split, this is not a problem */
uint8_t buf[BUF_SIZE];
uint32_t buf_used;
-} SpiceVmcPipeItem;
+} RedVmcPipeItem;
typedef struct SpiceVmcState {
RedChannel channel; /* Must be the first item */
RedChannelClient *rcc;
RedCharDevice *chardev;
SpiceCharDeviceInstance *chardev_sin;
- SpiceVmcPipeItem *pipe_item;
+ RedVmcPipeItem *pipe_item;
RedCharDeviceWriteBuffer *recv_from_client_buf;
uint8_t port_opened;
} SpiceVmcState;
@@ -87,22 +87,22 @@ static RedCharDevice *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc, RED_TYPE_CHAR_DEVICE)
-typedef struct PortInitPipeItem {
+typedef struct RedPortInitPipeItem {
RedPipeItem base;
char* name;
uint8_t opened;
-} PortInitPipeItem;
+} RedPortInitPipeItem;
-typedef struct PortEventPipeItem {
+typedef struct RedPortEventPipeItem {
RedPipeItem base;
uint8_t event;
-} PortEventPipeItem;
+} RedPortEventPipeItem;
enum {
- PIPE_ITEM_TYPE_SPICEVMC_DATA = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
- PIPE_ITEM_TYPE_PORT_INIT,
- PIPE_ITEM_TYPE_PORT_EVENT,
+ RED_PIPE_ITEM_TYPE_SPICEVMC_DATA = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_PORT_INIT,
+ RED_PIPE_ITEM_TYPE_PORT_EVENT,
};
static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
@@ -110,7 +110,7 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
{
SpiceVmcState *state = opaque;
SpiceCharDeviceInterface *sif;
- SpiceVmcPipeItem *msg_item;
+ RedVmcPipeItem *msg_item;
int n;
sif = spice_char_device_get_interface(sin);
@@ -120,8 +120,8 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
}
if (!state->pipe_item) {
- msg_item = spice_new0(SpiceVmcPipeItem, 1);
- red_pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
+ msg_item = spice_new0(RedVmcPipeItem, 1);
+ red_pipe_item_init(&msg_item->base, RED_PIPE_ITEM_TYPE_SPICEVMC_DATA);
} else {
spice_assert(state->pipe_item->buf_used == 0);
msg_item = state->pipe_item;
@@ -145,7 +145,7 @@ static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
void *opaque)
{
SpiceVmcState *state = opaque;
- SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
+ RedVmcPipeItem *vmc_msg = (RedVmcPipeItem *)msg;
spice_assert(state->rcc->client == client);
red_pipe_item_ref(vmc_msg);
@@ -156,9 +156,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
{
SpiceVmcState *state = SPICE_CONTAINEROF(rcc->channel, SpiceVmcState, channel);
SpiceCharDeviceInstance *sin = state->chardev_sin;
- PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
+ RedPortInitPipeItem *item = spice_malloc(sizeof(RedPortInitPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_INIT);
item->name = strdup(sin->portname);
item->opened = state->port_opened;
red_channel_client_pipe_add_push(rcc, &item->base);
@@ -166,9 +166,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
static void spicevmc_port_send_event(RedChannelClient *rcc, uint8_t event)
{
- PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
+ RedPortEventPipeItem *item = spice_malloc(sizeof(RedPortEventPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_EVENT);
item->event = event;
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -252,7 +252,7 @@ static SpiceVmcState *spicevmc_red_channel_client_get_state(RedChannelClient *rc
static int spicevmc_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
return TRUE;
}
@@ -369,7 +369,7 @@ static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
+ RedVmcPipeItem *i = SPICE_CONTAINEROF(item, RedVmcPipeItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_SPICEVMC_DATA, item);
spice_marshaller_add_ref(m, i->buf, i->buf_used);
@@ -393,7 +393,7 @@ static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
+ RedPortInitPipeItem *i = SPICE_CONTAINEROF(item, RedPortInitPipeItem, base);
SpiceMsgPortInit init;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_INIT, item);
@@ -407,7 +407,7 @@ static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem, base);
+ RedPortEventPipeItem *i = SPICE_CONTAINEROF(item, RedPortEventPipeItem, base);
SpiceMsgPortEvent event;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_EVENT, item);
@@ -421,16 +421,16 @@ static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_SPICEVMC_DATA:
+ case RED_PIPE_ITEM_TYPE_SPICEVMC_DATA:
spicevmc_red_channel_send_data(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
spicevmc_red_channel_send_migrate_data(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_PORT_INIT:
+ case RED_PIPE_ITEM_TYPE_PORT_INIT:
spicevmc_red_channel_send_port_init(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_PORT_EVENT:
+ case RED_PIPE_ITEM_TYPE_PORT_EVENT:
spicevmc_red_channel_send_port_event(rcc, m, item);
break;
default:
@@ -445,7 +445,7 @@ static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item,
int item_pushed)
{
- if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
+ if (item->type == RED_PIPE_ITEM_TYPE_SPICEVMC_DATA) {
red_pipe_item_unref(item);
} else {
free(item);
diff --git a/server/stream.c b/server/stream.c
index 47f6a99..5020eb0 100644
--- a/server/stream.c
+++ b/server/stream.c
@@ -133,7 +133,7 @@ void stream_agent_unref(DisplayChannel *display, StreamAgent *agent)
stream_unref(display, agent->stream);
}
-void stream_clip_item_free(StreamClipItem *item)
+void red_stream_clip_item_free(RedStreamClipItem *item)
{
g_return_if_fail(item != NULL);
DisplayChannel *display = DCC_TO_DC(item->stream_agent->dcc);
@@ -145,11 +145,11 @@ void stream_clip_item_free(StreamClipItem *item)
free(item);
}
-StreamClipItem *stream_clip_item_new(StreamAgent *agent)
+RedStreamClipItem *red_stream_clip_item_new(StreamAgent *agent)
{
- StreamClipItem *item = spice_new(StreamClipItem, 1);
- red_pipe_item_init_full((RedPipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
- (GDestroyNotify)stream_clip_item_free);
+ RedStreamClipItem *item = spice_new(RedStreamClipItem, 1);
+ red_pipe_item_init_full((RedPipeItem *)item, RED_PIPE_ITEM_TYPE_STREAM_CLIP,
+ (GDestroyNotify)red_stream_clip_item_free);
item->stream_agent = agent;
agent->stream->refs++;
@@ -316,7 +316,7 @@ void detach_stream(DisplayChannel *display, Stream *stream,
static void before_reattach_stream(DisplayChannel *display,
Stream *stream, Drawable *new_frame)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
DisplayChannelClient *dcc;
int index;
StreamAgent *agent;
@@ -731,11 +731,11 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &agent->create_item);
if (red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT)) {
- StreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
+ RedStreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
agent->report_id = rand();
red_pipe_item_init(&report_pipe_item->pipe_item,
- PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
+ RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &report_pipe_item->pipe_item);
}
@@ -758,7 +758,7 @@ void stream_agent_stop(StreamAgent *agent)
}
}
-static void upgrade_item_free(UpgradeItem *item)
+static void red_upgrade_item_free(RedUpgradeItem *item)
{
g_return_if_fail(item != NULL);
g_return_if_fail(item->base.refcount != 0);
@@ -792,7 +792,7 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
if (stream->current &&
region_contains(&stream->current->tree_item.base.rgn, &agent->vis_region)) {
RedChannelClient *rcc;
- UpgradeItem *upgrade_item;
+ RedUpgradeItem *upgrade_item;
int n_rects;
/* (1) The caller should detach the drawable from the stream. This will
@@ -807,9 +807,9 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
stream_id, stream->current->sized_stream != NULL);
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
- upgrade_item = spice_new(UpgradeItem, 1);
- red_pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
- (GDestroyNotify)upgrade_item_free);
+ upgrade_item = spice_new(RedUpgradeItem, 1);
+ red_pipe_item_init_full(&upgrade_item->base, RED_PIPE_ITEM_TYPE_UPGRADE,
+ (GDestroyNotify)red_upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
n_rects = pixman_region32_n_rects(&upgrade_item->drawable->tree_item.base.rgn);
diff --git a/server/stream.h b/server/stream.h
index 5b59212..bff7ca7 100644
--- a/server/stream.h
+++ b/server/stream.h
@@ -46,10 +46,10 @@ typedef struct DisplayChannel DisplayChannel;
typedef struct Stream Stream;
-typedef struct StreamActivateReportItem {
+typedef struct RedStreamActivateReportItem {
RedPipeItem pipe_item;
uint32_t stream_id;
-} StreamActivateReportItem;
+} RedStreamActivateReportItem;
enum {
STREAM_FRAME_NONE,
@@ -99,14 +99,14 @@ typedef struct StreamAgent {
#endif
} StreamAgent;
-typedef struct StreamClipItem {
+typedef struct RedStreamClipItem {
RedPipeItem base;
StreamAgent *stream_agent;
int clip_type;
SpiceClipRects *rects;
-} StreamClipItem;
+} RedStreamClipItem;
-StreamClipItem * stream_clip_item_new (StreamAgent *agent);
+RedStreamClipItem * red_stream_clip_item_new (StreamAgent *agent);
typedef struct ItemTrace {
red_time_t time;
commit b9720d80e0b8aaf6919de5f09ba9bfd510ebd7dd
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Apr 14 14:09:31 2016 -0500
Rename PipeItem to RedPipeItem
Following internal type naming conventions
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/cache-item.h b/server/cache-item.h
index 7dfb1af..90c82d3 100644
--- a/server/cache-item.h
+++ b/server/cache-item.h
@@ -25,7 +25,7 @@ typedef struct CacheItem CacheItem;
struct CacheItem {
union {
- PipeItem pipe_data;
+ RedPipeItem pipe_data;
struct {
RingItem lru_link;
CacheItem *next;
diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
index 23b0bc1..d63e576 100644
--- a/server/cache-item.tmpl.c
+++ b/server/cache-item.tmpl.c
@@ -81,7 +81,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
channel_client->VAR_NAME(items)--;
channel_client->VAR_NAME(available) += item->size;
- pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
+ red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
red_channel_client_pipe_add_tail_and_push(&channel_client->common.base, &item->u.pipe_data); // for now
}
diff --git a/server/char-device.c b/server/char-device.c
index 6cb6864..6e612ba 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -96,7 +96,7 @@ enum {
static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_buf);
static void red_char_device_write_retry(void *opaque);
-static PipeItem *
+static RedPipeItem *
red_char_device_read_one_msg_from_device(RedCharDevice *dev)
{
RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
@@ -106,7 +106,7 @@ red_char_device_read_one_msg_from_device(RedCharDevice *dev)
static void
red_char_device_send_msg_to_client(RedCharDevice *dev,
- PipeItem *msg,
+ RedPipeItem *msg,
RedClient *client)
{
RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
@@ -190,7 +190,7 @@ static void red_char_device_client_free(RedCharDevice *dev,
dev_client->wait_for_tokens_timer = NULL;
}
- g_queue_free_full(dev_client->send_queue, pipe_item_unref);
+ g_queue_free_full(dev_client->send_queue, red_pipe_item_unref);
/* remove write buffers that are associated with the client */
spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->priv->write_queue) && !dev->priv->cur_write_buf);
@@ -278,7 +278,7 @@ static uint64_t red_char_device_max_send_tokens(RedCharDevice *dev)
}
static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_client,
- PipeItem *msg)
+ RedPipeItem *msg)
{
RedCharDevice *dev = dev_client->dev;
@@ -287,7 +287,7 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
return;
}
- pipe_item_ref(msg);
+ red_pipe_item_ref(msg);
g_queue_push_head(dev_client->send_queue, msg);
if (!dev_client->wait_for_tokens_started) {
reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
@@ -297,7 +297,7 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
}
static void red_char_device_send_msg_to_clients(RedCharDevice *dev,
- PipeItem *msg)
+ RedPipeItem *msg)
{
RingItem *item, *next;
@@ -343,7 +343,7 @@ static int red_char_device_read_from_device(RedCharDevice *dev)
* All messages will be discarded if no client is attached to the device
*/
while ((max_send_tokens || ring_is_empty(&dev->priv->clients)) && dev->priv->running) {
- PipeItem *msg;
+ RedPipeItem *msg;
msg = red_char_device_read_one_msg_from_device(dev);
if (!msg) {
@@ -356,7 +356,7 @@ static int red_char_device_read_from_device(RedCharDevice *dev)
}
did_read = TRUE;
red_char_device_send_msg_to_clients(dev, msg);
- pipe_item_unref(msg);
+ red_pipe_item_unref(msg);
max_send_tokens--;
}
dev->priv->during_read_from_device = 0;
@@ -371,12 +371,12 @@ static void red_char_device_client_send_queue_push(RedCharDeviceClient *dev_clie
{
while (!g_queue_is_empty(dev_client->send_queue) &&
red_char_device_can_send_to_client(dev_client)) {
- PipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
+ RedPipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
g_assert(msg != NULL);
dev_client->num_send_tokens--;
red_char_device_send_msg_to_client(dev_client->dev, msg,
dev_client->client);
- pipe_item_unref(msg);
+ red_pipe_item_unref(msg);
}
}
@@ -851,7 +851,7 @@ void red_char_device_reset(RedCharDevice *dev)
dev_client = SPICE_CONTAINEROF(client_item, RedCharDeviceClient, link);
spice_debug("send_queue_empty %d", g_queue_is_empty(dev_client->send_queue));
dev_client->num_send_tokens += g_queue_get_length(dev_client->send_queue);
- g_queue_foreach(dev_client->send_queue, (GFunc)pipe_item_unref, NULL);
+ g_queue_foreach(dev_client->send_queue, (GFunc)red_pipe_item_unref, NULL);
g_queue_clear(dev_client->send_queue);
}
red_char_device_reset_dev_instance(dev, NULL);
diff --git a/server/char-device.h b/server/char-device.h
index f793c54..d05b1fd 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -56,10 +56,10 @@ struct RedCharDeviceClass
/* reads from the device till reaching a msg that should be sent to the client,
* or till the reading fails */
- PipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
- void *opaque);
+ RedPipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
+ void *opaque);
/* after this call, the message is unreferenced */
- void (*send_msg_to_client)(PipeItem *msg,
+ void (*send_msg_to_client)(RedPipeItem *msg,
RedClient *client,
void *opaque);
diff --git a/server/cursor-channel.c b/server/cursor-channel.c
index 7d5ac6a..e2bb706 100644
--- a/server/cursor-channel.c
+++ b/server/cursor-channel.c
@@ -46,7 +46,7 @@ typedef struct CursorItem {
G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
typedef struct CursorPipeItem {
- PipeItem base;
+ RedPipeItem base;
CursorItem *cursor_item;
int refs;
} CursorPipeItem;
@@ -132,11 +132,11 @@ static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
cursor->item = item ? cursor_item_ref(item) : NULL;
}
-static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
+static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
{
CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
item->refs = 1;
item->cursor_item = data;
item->cursor_item->refs++;
@@ -212,7 +212,7 @@ static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_
return;
}
- spice_assert(!pipe_item_is_linked(&pipe_item->base));
+ spice_assert(!red_pipe_item_is_linked(&pipe_item->base));
cursor_item_unref(pipe_item->cursor_item);
free(pipe_item);
@@ -229,7 +229,7 @@ static void cursor_channel_client_on_disconnect(RedChannelClient *rcc)
// 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,
- PipeItem *item)
+ RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
@@ -249,7 +249,7 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
}
static void cursor_channel_client_release_item_after_push(CursorChannelClient *ccc,
- PipeItem *item)
+ RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_CURSOR: {
@@ -263,7 +263,7 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
}
static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *base_marshaller,
- PipeItem *pipe_item)
+ RedPipeItem *pipe_item)
{
CursorChannel *cursor_channel;
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@@ -290,7 +290,7 @@ static void cursor_marshall(RedChannelClient *rcc,
CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
CursorItem *item = cursor_pipe_item->cursor_item;
- PipeItem *pipe_item = &cursor_pipe_item->base;
+ RedPipeItem *pipe_item = &cursor_pipe_item->base;
RedCursorCmd *cmd;
spice_return_if_fail(cursor_channel);
@@ -348,7 +348,7 @@ static inline void red_marshall_inval(RedChannelClient *rcc,
spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
}
-static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item)
+static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@@ -389,7 +389,7 @@ static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
}
-static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
CursorPipeItem *cursor_pipe_item;
@@ -399,7 +399,7 @@ static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
cursor_pipe_item_ref(cursor_pipe_item);
}
-static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
+static void cursor_channel_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
diff --git a/server/dcc-send.c b/server/dcc-send.c
index b8d1157..799d5df 100644
--- a/server/dcc-send.c
+++ b/server/dcc-send.c
@@ -186,9 +186,9 @@ static int is_brush_lossy(RedChannelClient *rcc, SpiceBrush *brush,
}
}
-static PipeItem *dcc_get_tail(DisplayChannelClient *dcc)
+static RedPipeItem *dcc_get_tail(DisplayChannelClient *dcc)
{
- return (PipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
+ return (RedPipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
}
static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
@@ -596,15 +596,15 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
SpiceRect *surface_areas[],
int num_surfaces)
{
- PipeItem *pipe_item;
+ RedPipeItem *pipe_item;
Ring *pipe;
spice_assert(num_surfaces);
pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
- for (pipe_item = (PipeItem *)ring_get_head(pipe);
+ for (pipe_item = (RedPipeItem *)ring_get_head(pipe);
pipe_item;
- pipe_item = (PipeItem *)ring_next(pipe, &pipe_item->link))
+ pipe_item = (RedPipeItem *)ring_next(pipe, &pipe_item->link))
{
Drawable *drawable;
@@ -685,7 +685,7 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
int resent_surface_ids[MAX_PIPE_SIZE];
SpiceRect resent_areas[MAX_PIPE_SIZE]; // not pointers since drawables may be released
int num_resent;
- PipeItem *pipe_item;
+ RedPipeItem *pipe_item;
Ring *pipe;
resent_surface_ids[0] = first_surface_id;
@@ -695,9 +695,9 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
// going from the oldest to the newest
- for (pipe_item = (PipeItem *)ring_get_tail(pipe);
+ for (pipe_item = (RedPipeItem *)ring_get_tail(pipe);
pipe_item;
- pipe_item = (PipeItem *)ring_prev(pipe, &pipe_item->link)) {
+ pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
Drawable *drawable;
DrawablePipeItem *dpi;
ImageItem *image;
@@ -2301,7 +2301,7 @@ static void marshall_stream_activate_report(RedChannelClient *rcc,
static void marshall_gl_scanout(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display_channel = DCC_TO_DC(dcc);
@@ -2317,7 +2317,7 @@ static void marshall_gl_scanout(RedChannelClient *rcc,
static void marshall_gl_draw(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
@@ -2360,7 +2360,7 @@ static void reset_send_data(DisplayChannelClient *dcc)
memset(dcc->send_data.free_list.sync, 0, sizeof(dcc->send_data.free_list.sync));
}
-void dcc_send_item(DisplayChannelClient *dcc, PipeItem *pipe_item)
+void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
{
RedChannelClient *rcc = RED_CHANNEL_CLIENT(dcc);
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
diff --git a/server/dcc.c b/server/dcc.c
index 4fe7652..330127b 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -38,7 +38,7 @@ static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
create->surface_create.flags = flags;
create->surface_create.format = format;
- pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
+ red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
return create;
}
@@ -64,7 +64,7 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
int wait_if_used)
{
Ring *ring;
- PipeItem *item;
+ RedPipeItem *item;
int x;
RedChannelClient *rcc;
@@ -74,8 +74,8 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
rcc = RED_CHANNEL_CLIENT(dcc);
ring = &rcc->pipe;
- item = (PipeItem *) ring;
- while ((item = (PipeItem *)ring_next(ring, (RingItem *)item))) {
+ item = (RedPipeItem *) ring;
+ while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
Drawable *drawable;
DrawablePipeItem *dpi = NULL;
int depend_found = FALSE;
@@ -90,11 +90,11 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
}
if (drawable->surface_id == surface_id) {
- PipeItem *tmp_item = item;
- item = (PipeItem *)ring_prev(ring, (RingItem *)item);
+ RedPipeItem *tmp_item = item;
+ item = (RedPipeItem *)ring_prev(ring, (RingItem *)item);
red_channel_client_pipe_remove_and_release(rcc, tmp_item);
if (!item) {
- item = (PipeItem *)ring;
+ item = (RedPipeItem *)ring;
}
continue;
}
@@ -163,7 +163,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
// adding the pipe item after pos. If pos == NULL, adding to head.
ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
- SpiceRect *area, PipeItem *pos, int can_lossy)
+ SpiceRect *area, RedPipeItem *pos, int can_lossy)
{
DisplayChannel *display = DCC_TO_DC(dcc);
RedSurface *surface = &display->surfaces[surface_id];
@@ -184,7 +184,7 @@ ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
item = (ImageItem *)spice_malloc_n_m(height, stride, sizeof(ImageItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
item->surface_id = surface_id;
item->image_format =
@@ -274,7 +274,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
dcc_push_surface_image(dcc, drawable->surface_id);
}
-void drawable_pipe_item_free(PipeItem *item)
+void drawable_pipe_item_free(RedPipeItem *item)
{
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
spice_assert(item->refcount == 0);
@@ -294,8 +294,8 @@ static DrawablePipeItem *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawa
dpi->dcc = dcc;
ring_item_init(&dpi->base);
ring_add(&drawable->pipes, &dpi->base);
- pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
- (GDestroyNotify)drawable_pipe_item_free);
+ red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
+ (GDestroyNotify)drawable_pipe_item_free);
drawable->refs++;
return dpi;
}
@@ -316,7 +316,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
}
-void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, PipeItem *pos)
+void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, RedPipeItem *pos)
{
DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
@@ -334,8 +334,8 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
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);
+ red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
+ red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
}
dcc->use_mjpeg_encoder_rate_control =
red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
@@ -505,7 +505,7 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
item->rects->num_rects = n_rects;
region_ret_rects(&agent->clip, item->rects->rects, n_rects);
- red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (PipeItem *)item);
+ red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem *)item);
}
static void monitors_config_item_free(MonitorsConfigItem *item)
@@ -522,8 +522,8 @@ static MonitorsConfigItem *monitors_config_item_new(RedChannel* channel,
mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci->monitors_config = monitors_config;
- pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
- (GDestroyNotify)monitors_config_item_free);
+ red_pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
+ (GDestroyNotify)monitors_config_item_free);
return mci;
}
@@ -556,12 +556,12 @@ static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel,
destroy = spice_malloc(sizeof(SurfaceDestroyItem));
destroy->surface_destroy.surface_id = surface_id;
- pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
+ red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
return destroy;
}
-PipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
+RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
{
GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
@@ -574,12 +574,12 @@ PipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
return NULL;
}
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
return &item->base;
}
-PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
+RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
const SpiceMsgDisplayGlDraw *draw = data;
@@ -594,7 +594,7 @@ PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
dcc->gl_draw_ongoing = TRUE;
item->draw = *draw;
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
return &item->base;
}
@@ -1589,7 +1589,7 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
return TRUE;
}
-static void release_item_after_push(PipeItem *item)
+static void release_item_after_push(RedPipeItem *item)
{
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW:
@@ -1597,7 +1597,7 @@ static void release_item_after_push(PipeItem *item)
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
case PIPE_ITEM_TYPE_UPGRADE:
- pipe_item_unref(item);
+ red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
@@ -1611,7 +1611,7 @@ static void release_item_after_push(PipeItem *item)
// TODO: share code between before/after_push since most of the items need the same
// release
-static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
+static void release_item_before_push(DisplayChannelClient *dcc, RedPipeItem *item)
{
DisplayChannel *display = DCC_TO_DC(dcc);
@@ -1620,7 +1620,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
case PIPE_ITEM_TYPE_DRAW: {
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
ring_remove(&dpi->base);
- pipe_item_unref(item);
+ red_pipe_item_unref(item);
break;
}
case PIPE_ITEM_TYPE_STREAM_CREATE: {
@@ -1637,7 +1637,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
case PIPE_ITEM_TYPE_UPGRADE:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
- pipe_item_unref(item);
+ red_pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_CREATE_SURFACE: {
SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, SurfaceCreateItem,
@@ -1667,7 +1667,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
}
}
-void dcc_release_item(DisplayChannelClient *dcc, PipeItem *item, int item_pushed)
+void dcc_release_item(DisplayChannelClient *dcc, RedPipeItem *item, int item_pushed)
{
if (item_pushed)
release_item_after_push(item);
diff --git a/server/dcc.h b/server/dcc.h
index e8354e2..52cd22a 100644
--- a/server/dcc.h
+++ b/server/dcc.h
@@ -123,20 +123,20 @@ struct DisplayChannelClient {
typedef struct SurfaceCreateItem {
SpiceMsgSurfaceCreate surface_create;
- PipeItem pipe_item;
+ RedPipeItem pipe_item;
} SurfaceCreateItem;
typedef struct GlScanoutUnixItem {
- PipeItem base;
+ RedPipeItem base;
} GlScanoutUnixItem;
typedef struct GlDrawItem {
- PipeItem base;
+ RedPipeItem base;
SpiceMsgDisplayGlDraw draw;
} GlDrawItem;
typedef struct ImageItem {
- PipeItem base;
+ RedPipeItem base;
SpicePoint pos;
int width;
int height;
@@ -151,7 +151,7 @@ typedef struct ImageItem {
typedef struct DrawablePipeItem {
RingItem base; /* link for a list of pipe items held by Drawable */
- PipeItem dpi_pipe_item; /* link for the client's pipe itself */
+ RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
Drawable *drawable;
DisplayChannelClient *dcc;
uint8_t refs;
@@ -189,7 +189,7 @@ void dcc_push_surface_image (DisplayCha
ImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
- PipeItem *pos,
+ RedPipeItem *pos,
int can_lossy);
void dcc_palette_cache_reset (DisplayChannelClient *dcc);
void dcc_palette_cache_palette (DisplayChannelClient *dcc,
@@ -203,20 +203,20 @@ void dcc_append_drawable (DisplayCha
Drawable *drawable);
void dcc_add_drawable_after (DisplayChannelClient *dcc,
Drawable *drawable,
- PipeItem *pos);
+ RedPipeItem *pos);
void dcc_release_item (DisplayChannelClient *dcc,
- PipeItem *item,
+ RedPipeItem *item,
int item_pushed);
void dcc_send_item (DisplayChannelClient *dcc,
- PipeItem *item);
+ RedPipeItem *item);
int dcc_clear_surface_drawables_from_pipe (DisplayChannelClient *dcc,
int surface_id,
int wait_if_used);
int dcc_drawable_is_in_pipe (DisplayChannelClient *dcc,
Drawable *drawable);
-PipeItem * dcc_gl_scanout_item_new (RedChannelClient *rcc,
+RedPipeItem * dcc_gl_scanout_item_new (RedChannelClient *rcc,
void *data, int num);
-PipeItem * dcc_gl_draw_item_new (RedChannelClient *rcc,
+RedPipeItem * dcc_gl_draw_item_new (RedChannelClient *rcc,
void *data, int num);
typedef struct compress_send_data_t {
diff --git a/server/display-channel.c b/server/display-channel.c
index 93c111b..5dc593c 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -401,7 +401,7 @@ static void drawable_remove_from_pipes(Drawable *drawable)
RING_FOREACH_SAFE(item, next, &drawable->pipes) {
dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
- if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
+ if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi->dcc),
&dpi->dpi_pipe_item);
}
@@ -1958,12 +1958,12 @@ static void on_disconnect(RedChannelClient *rcc)
display->glz_drawable_count);
}
-static void send_item(RedChannelClient *rcc, PipeItem *item)
+static void send_item(RedChannelClient *rcc, RedPipeItem *item)
{
dcc_send_item(RCC_TO_DCC(rcc), item);
}
-static void hold_item(RedChannelClient *rcc, PipeItem *item)
+static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
{
spice_return_if_fail(item);
@@ -1972,14 +1972,14 @@ static void hold_item(RedChannelClient *rcc, PipeItem *item)
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
- pipe_item_ref(item);
+ red_pipe_item_ref(item);
break;
default:
spice_warn_if_reached();
}
}
-static void release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
+static void release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
diff --git a/server/display-channel.h b/server/display-channel.h
index 1ccedaf..bf2e4f0 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -58,7 +58,7 @@ struct Drawable {
RingItem list_link;
DrawItem tree_item;
Ring pipes;
- PipeItem *pipe_item_rest;
+ RedPipeItem *pipe_item_rest;
uint32_t size_pipe_item_rest;
RedDrawable *red_drawable;
@@ -120,7 +120,7 @@ typedef struct MonitorsConfig {
} MonitorsConfig;
typedef struct MonitorsConfigItem {
- PipeItem pipe_item;
+ RedPipeItem pipe_item;
MonitorsConfig *monitors_config;
} MonitorsConfigItem;
@@ -242,11 +242,11 @@ static inline int get_stream_id(DisplayChannel *display, Stream *stream)
typedef struct SurfaceDestroyItem {
SpiceMsgSurfaceDestroy surface_destroy;
- PipeItem pipe_item;
+ RedPipeItem pipe_item;
} SurfaceDestroyItem;
typedef struct UpgradeItem {
- PipeItem base;
+ RedPipeItem base;
Drawable *drawable;
SpiceClipRects *rects;
} UpgradeItem;
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 45e0a8f..81a8d4a 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -123,16 +123,16 @@ enum {
};
typedef struct InputsPipeItem {
- PipeItem base;
+ RedPipeItem base;
} InputsPipeItem;
typedef struct KeyModifiersPipeItem {
- PipeItem base;
+ RedPipeItem base;
uint8_t modifiers;
} KeyModifiersPipeItem;
typedef struct InputsInitPipeItem {
- PipeItem base;
+ RedPipeItem base;
uint8_t modifiers;
} InputsInitPipeItem;
@@ -229,19 +229,19 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
return sif->get_leds(sin);
}
-static PipeItem *inputs_key_modifiers_item_new(
+static RedPipeItem *inputs_key_modifiers_item_new(
RedChannelClient *rcc, void *data, int num)
{
KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
+ red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
item->modifiers = *(uint8_t *)data;
return &item->base;
}
static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
@@ -255,12 +255,12 @@ static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
}
static void inputs_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed)
+ RedPipeItem *base, int item_pushed)
{
free(base);
}
-static void inputs_channel_send_item(RedChannelClient *rcc, PipeItem *base)
+static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@@ -503,7 +503,7 @@ static void inputs_pipe_add_init(RedChannelClient *rcc)
InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
- pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
+ red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -524,7 +524,7 @@ static int inputs_channel_config_socket(RedChannelClient *rcc)
return TRUE;
}
-static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
}
diff --git a/server/main-channel.c b/server/main-channel.c
index a9d0ce1..b904e33 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -79,28 +79,28 @@ enum {
};
typedef struct RefsPipeItem {
- PipeItem base;
+ RedPipeItem base;
int *refs;
} RefsPipeItem;
typedef struct PingPipeItem {
- PipeItem base;
+ RedPipeItem base;
int size;
} PingPipeItem;
typedef struct MouseModePipeItem {
- PipeItem base;
+ RedPipeItem base;
int current_mode;
int is_client_mouse_allowed;
} MouseModePipeItem;
typedef struct TokensPipeItem {
- PipeItem base;
+ RedPipeItem base;
int tokens;
} TokensPipeItem;
typedef struct AgentDataPipeItem {
- PipeItem base;
+ RedPipeItem base;
uint8_t* data;
size_t len;
spice_marshaller_item_free_func free_data;
@@ -108,7 +108,7 @@ typedef struct AgentDataPipeItem {
} AgentDataPipeItem;
typedef struct InitPipeItem {
- PipeItem base;
+ RedPipeItem base;
int connection_id;
int display_channels_hint;
int current_mouse_mode;
@@ -118,22 +118,22 @@ typedef struct InitPipeItem {
} InitPipeItem;
typedef struct NamePipeItem {
- PipeItem base;
+ RedPipeItem base;
SpiceMsgMainName msg;
} NamePipeItem;
typedef struct UuidPipeItem {
- PipeItem base;
+ RedPipeItem base;
SpiceMsgMainUuid msg;
} UuidPipeItem;
typedef struct NotifyPipeItem {
- PipeItem base;
+ RedPipeItem base;
char *msg;
} NotifyPipeItem;
typedef struct MultiMediaTimePipeItem {
- PipeItem base;
+ RedPipeItem base;
int time;
} MultiMediaTimePipeItem;
@@ -166,7 +166,7 @@ enum NetTestStage {
};
static void main_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed);
+ RedPipeItem *base, int item_pushed);
int main_channel_is_connected(MainChannel *main_chan)
{
@@ -221,42 +221,42 @@ typedef struct MainMouseModeItemInfo {
int is_client_mouse_allowed;
} MainMouseModeItemInfo;
-static PipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
+static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
{
MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
MainMouseModeItemInfo *info = data;
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
item->current_mode = info->current_mode;
item->is_client_mouse_allowed = info->is_client_mouse_allowed;
return &item->base;
}
-static PipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
+static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
{
PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
item->size = size;
return &item->base;
}
-static PipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
+static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
{
TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
item->tokens = num_tokens;
return &item->base;
}
-static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
- spice_marshaller_item_free_func free_data,
- void *opaque)
+static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
+ spice_marshaller_item_free_func free_data,
+ void *opaque)
{
AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
item->data = data;
item->len = len;
item->free_data = free_data;
@@ -264,14 +264,14 @@ static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data,
return &item->base;
}
-static PipeItem *main_init_item_new(MainChannelClient *mcc,
+static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
int connection_id, int display_channels_hint, int current_mouse_mode,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
item->connection_id = connection_id;
item->display_channels_hint = display_channels_hint;
item->current_mouse_mode = current_mouse_mode;
@@ -281,44 +281,44 @@ static PipeItem *main_init_item_new(MainChannelClient *mcc,
return &item->base;
}
-static PipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
+static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
{
NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
item->msg.name_len = strlen(name) + 1;
memcpy(&item->msg.name, name, item->msg.name_len);
return &item->base;
}
-static PipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
+static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
{
UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
return &item->base;
}
-static PipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
+static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
{
NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
const char *msg = data;
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
item->msg = spice_strdup(msg);
return &item->base;
}
-static PipeItem *main_multi_media_time_item_new(
+static RedPipeItem *main_multi_media_time_item_new(
RedChannelClient *rcc, void *data, int num)
{
MultiMediaTimePipeItem *item, *info = data;
item = spice_malloc(sizeof(MultiMediaTimePipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item->time = info->time;
return &item->base;
}
@@ -335,7 +335,7 @@ static void main_channel_push_channels(MainChannelClient *mcc)
static void main_channel_marshall_channels(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgChannels* channels_info;
@@ -349,7 +349,7 @@ static void main_channel_marshall_channels(RedChannelClient *rcc,
int main_channel_client_push_ping(MainChannelClient *mcc, int size)
{
- PipeItem *item;
+ RedPipeItem *item;
if (mcc == NULL) {
return FALSE;
@@ -417,7 +417,7 @@ void main_channel_push_agent_connected(MainChannel *main_chan)
static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgMainAgentConnectedTokens connected;
@@ -433,7 +433,7 @@ void main_channel_push_agent_disconnected(MainChannel *main_chan)
static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgMainAgentDisconnect disconnect;
@@ -444,7 +444,7 @@ static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
{
- PipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
+ RedPipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
red_channel_client_pipe_add_push(&mcc->base, item);
}
@@ -462,7 +462,7 @@ static void main_channel_marshall_tokens(RedChannelClient *rcc,
void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data, void *opaque)
{
- PipeItem *item;
+ RedPipeItem *item;
item = main_agent_data_item_new(&mcc->base, data, len, free_data, opaque);
red_channel_client_pipe_add_push(&mcc->base, item);
@@ -482,7 +482,8 @@ static void main_channel_push_migrate_data_item(MainChannel *main_chan)
}
static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
- SpiceMarshaller *m, PipeItem *item)
+ SpiceMarshaller *m,
+ RedPipeItem *item)
{
red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
reds_marshall_migrate_data(rcc->channel->reds, m); // TODO: from reds split. ugly separation.
@@ -515,7 +516,7 @@ void main_channel_push_init(MainChannelClient *mcc,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
- PipeItem *item;
+ RedPipeItem *item;
item = main_init_item_new(mcc,
mcc->connection_id, display_channels_hint, current_mouse_mode,
@@ -547,7 +548,7 @@ static void main_channel_marshall_init(RedChannelClient *rcc,
void main_channel_push_name(MainChannelClient *mcc, const char *name)
{
- PipeItem *item;
+ RedPipeItem *item;
if (!red_channel_client_test_remote_cap(&mcc->base,
SPICE_MAIN_CAP_NAME_AND_UUID))
@@ -559,7 +560,7 @@ void main_channel_push_name(MainChannelClient *mcc, const char *name)
void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
{
- PipeItem *item;
+ RedPipeItem *item;
if (!red_channel_client_test_remote_cap(&mcc->base,
SPICE_MAIN_CAP_NAME_AND_UUID))
@@ -571,7 +572,7 @@ void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
{
- PipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
+ RedPipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
red_channel_client_pipe_add_push(&mcc->base, item);
}
@@ -608,7 +609,7 @@ static void main_channel_fill_migrate_dst_info(MainChannel *main_channel,
}
static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgMainMigrationBegin migrate;
MainChannel *main_ch;
@@ -621,7 +622,7 @@ static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelCl
static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgMainMigrateBeginSeamless migrate_seamless;
MainChannel *main_ch;
@@ -665,7 +666,7 @@ void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_targe
}
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMsgMainMigrationSwitchHost migrate;
MainChannel *main_ch;
@@ -698,7 +699,7 @@ static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
spice_marshall_msg_main_multi_media_time(m, &time_mes);
}
-static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
+static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
{
MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@@ -783,7 +784,7 @@ static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
}
static void main_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed)
+ RedPipeItem *base, int item_pushed)
{
switch (base->type) {
case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
@@ -1022,7 +1023,7 @@ static int main_channel_config_socket(RedChannelClient *rcc)
return TRUE;
}
-static void main_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+static void main_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
}
diff --git a/server/red-channel.c b/server/red-channel.c
index 3e036c9..834ddb7 100644
--- a/server/red-channel.c
+++ b/server/red-channel.c
@@ -45,7 +45,7 @@
#include "utils.h"
typedef struct EmptyMsgPipeItem {
- PipeItem base;
+ RedPipeItem base;
int msg;
} EmptyMsgPipeItem;
@@ -510,7 +510,7 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc)
}
-static void red_channel_client_send_empty_msg(RedChannelClient *rcc, PipeItem *base)
+static void red_channel_client_send_empty_msg(RedChannelClient *rcc, RedPipeItem *base)
{
EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, EmptyMsgPipeItem, base);
@@ -557,7 +557,7 @@ static void red_channel_client_send_ping(RedChannelClient *rcc)
red_channel_client_begin_send_message(rcc);
}
-static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item)
+static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *item)
{
spice_assert(red_channel_client_no_item_being_sent(rcc));
red_channel_client_reset_send_data(rcc);
@@ -581,7 +581,7 @@ static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item)
free(item);
}
-static void red_channel_client_release_item(RedChannelClient *rcc, PipeItem *item, int item_pushed)
+static void red_channel_client_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
switch (item->type) {
case PIPE_ITEM_TYPE_SET_ACK:
@@ -643,7 +643,7 @@ static void red_channel_peer_on_out_msg_done(void *opaque)
}
-static void red_channel_client_pipe_remove(RedChannelClient *rcc, PipeItem *item)
+static void red_channel_client_pipe_remove(RedChannelClient *rcc, RedPipeItem *item)
{
rcc->pipe_size--;
ring_remove(&item->link);
@@ -1324,13 +1324,13 @@ static inline int red_channel_client_waiting_for_ack(RedChannelClient *rcc)
(rcc->ack_data.messages_window > rcc->ack_data.client_window * 2));
}
-static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
+static inline RedPipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
{
- PipeItem *item;
+ RedPipeItem *item;
if (!rcc || rcc->send_data.blocked
|| red_channel_client_waiting_for_ack(rcc)
- || !(item = (PipeItem *)ring_get_tail(&rcc->pipe))) {
+ || !(item = (RedPipeItem *)ring_get_tail(&rcc->pipe))) {
return NULL;
}
red_channel_client_pipe_remove(rcc, item);
@@ -1339,7 +1339,7 @@ static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient *rcc)
void red_channel_client_push(RedChannelClient *rcc)
{
- PipeItem *pipe_item;
+ RedPipeItem *pipe_item;
if (!rcc->during_send) {
rcc->during_send = TRUE;
@@ -1589,7 +1589,7 @@ static void red_channel_client_event(int fd, int event, void *data)
red_channel_client_unref(rcc);
}
-void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, PipeItem *item)
+void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, RedPipeItem *item)
{
spice_assert(red_channel_client_no_item_being_sent(rcc));
spice_assert(msg_type != 0);
@@ -1658,7 +1658,7 @@ void red_channel_client_set_message_serial(RedChannelClient *rcc, uint64_t seria
rcc->send_data.serial = serial;
}
-static inline gboolean client_pipe_add(RedChannelClient *rcc, PipeItem *item, RingItem *pos)
+static inline gboolean client_pipe_add(RedChannelClient *rcc, RedPipeItem *item, RingItem *pos)
{
spice_assert(rcc && item);
if (SPICE_UNLIKELY(!red_channel_client_is_connected(rcc))) {
@@ -1676,38 +1676,39 @@ static inline gboolean client_pipe_add(RedChannelClient *rcc, PipeItem *item, Ri
return TRUE;
}
-void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item)
+void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem *item)
{
client_pipe_add(rcc, item, &rcc->pipe);
}
-void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item)
+void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item)
{
red_channel_client_pipe_add(rcc, item);
red_channel_client_push(rcc);
}
void red_channel_client_pipe_add_after(RedChannelClient *rcc,
- PipeItem *item, PipeItem *pos)
+ RedPipeItem *item,
+ RedPipeItem *pos)
{
spice_assert(pos);
client_pipe_add(rcc, item, &pos->link);
}
int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
return ring_item_is_linked(&item->link);
}
void red_channel_client_pipe_add_tail(RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
client_pipe_add(rcc, item, rcc->pipe.prev);
}
-void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *item)
+void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, RedPipeItem *item)
{
if (client_pipe_add(rcc, item, rcc->pipe.prev)) {
red_channel_client_push(rcc);
@@ -1716,9 +1717,9 @@ void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *
void red_channel_client_pipe_add_type(RedChannelClient *rcc, int pipe_item_type)
{
- PipeItem *item = spice_new(PipeItem, 1);
+ RedPipeItem *item = spice_new(RedPipeItem, 1);
- pipe_item_init(item, pipe_item_type);
+ red_pipe_item_init(item, pipe_item_type);
red_channel_client_pipe_add(rcc, item);
red_channel_client_push(rcc);
}
@@ -1738,7 +1739,7 @@ void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
{
EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
item->msg = msg_type;
red_channel_client_pipe_add(rcc, &item->base);
red_channel_client_push(rcc);
@@ -1781,12 +1782,12 @@ void red_channel_client_clear_sent_item(RedChannelClient *rcc)
void red_channel_client_pipe_clear(RedChannelClient *rcc)
{
- PipeItem *item;
+ RedPipeItem *item;
if (rcc) {
red_channel_client_clear_sent_item(rcc);
}
- while ((item = (PipeItem *)ring_get_head(&rcc->pipe))) {
+ while ((item = (RedPipeItem *)ring_get_head(&rcc->pipe))) {
ring_remove(&item->link);
red_channel_client_release_item(rcc, item, FALSE);
}
@@ -2029,7 +2030,7 @@ int red_channel_client_no_item_being_sent(RedChannelClient *rcc)
}
void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
red_channel_client_pipe_remove(rcc, item);
red_channel_client_release_item(rcc, item, FALSE);
@@ -2231,8 +2232,8 @@ int red_client_during_migrate_at_target(RedClient *client)
* TODO - inline? macro? right now this is the simplest from code amount
*/
-typedef void (*rcc_item_t)(RedChannelClient *rcc, PipeItem *item);
-typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, PipeItem *item);
+typedef void (*rcc_item_t)(RedChannelClient *rcc, RedPipeItem *item);
+typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, RedPipeItem *item);
/**
* red_channel_pipes_create_batch:
@@ -2249,7 +2250,7 @@ static int red_channel_pipes_create_batch(RedChannel *channel,
{
RingItem *link, *next;
RedChannelClient *rcc;
- PipeItem *item;
+ RedPipeItem *item;
int num = 0, n = 0;
spice_assert(creator != NULL);
@@ -2362,7 +2363,7 @@ int red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
/* TODO: more evil sync stuff. anything with the word wait in it's name. */
int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
- PipeItem *item,
+ RedPipeItem *item,
int64_t timeout)
{
uint64_t end_time;
diff --git a/server/red-channel.h b/server/red-channel.h
index 3c762ff..be5ae99 100644
--- a/server/red-channel.h
+++ b/server/red-channel.h
@@ -158,10 +158,10 @@ typedef void (*channel_release_msg_recv_buf_proc)(RedChannelClient *channel,
uint16_t type, uint32_t size, uint8_t *msg);
typedef void (*channel_disconnect_proc)(RedChannelClient *rcc);
typedef int (*channel_configure_socket_proc)(RedChannelClient *rcc);
-typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc, PipeItem *item);
-typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc, PipeItem *item);
+typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc, RedPipeItem *item);
+typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc, RedPipeItem *item);
typedef void (*channel_release_pipe_item_proc)(RedChannelClient *rcc,
- PipeItem *item, int item_pushed);
+ RedPipeItem *item, int item_pushed);
typedef void (*channel_on_incoming_error_proc)(RedChannelClient *rcc);
typedef void (*channel_on_outgoing_error_proc)(RedChannelClient *rcc);
@@ -258,7 +258,7 @@ struct RedChannelClient {
SpiceMarshaller *marshaller;
SpiceDataHeaderOpaque header;
uint32_t size;
- PipeItem *item;
+ RedPipeItem *item;
int blocked;
uint64_t serial;
uint64_t last_sent_serial;
@@ -266,7 +266,7 @@ struct RedChannelClient {
struct {
SpiceMarshaller *marshaller;
uint8_t *header_data;
- PipeItem *item;
+ RedPipeItem *item;
} main;
struct {
@@ -434,7 +434,7 @@ int red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size,
uint16_t type, void *message);
/* when preparing send_data: should call init and then use marshaller */
-void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, PipeItem *item);
+void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, RedPipeItem *item);
uint64_t red_channel_client_get_message_serial(RedChannelClient *channel);
void red_channel_client_set_message_serial(RedChannelClient *channel, uint64_t);
@@ -465,20 +465,20 @@ int red_channel_client_get_roundtrip_ms(RedChannelClient *rcc);
void red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uint32_t timeout_ms);
// TODO: add back the channel_pipe_add functionality - by adding reference counting
-// to the PipeItem.
+// to the RedPipeItem.
// helper to push a new item to all channels
-typedef PipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data, int num);
+typedef RedPipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data, int num);
int red_channel_pipes_new_add_push(RedChannel *channel, new_pipe_item_t creator, void *data);
void red_channel_pipes_new_add(RedChannel *channel, new_pipe_item_t creator, void *data);
void red_channel_pipes_new_add_tail(RedChannel *channel, new_pipe_item_t creator, void *data);
-void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item);
-void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item);
-void red_channel_client_pipe_add_after(RedChannelClient *rcc, PipeItem *item, PipeItem *pos);
-int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc, PipeItem *item);
-void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc, PipeItem *item);
-void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *item);
+void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
+void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem *item);
+void red_channel_client_pipe_add_after(RedChannelClient *rcc, RedPipeItem *item, RedPipeItem *pos);
+int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc, RedPipeItem *item);
+void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc, RedPipeItem *item);
+void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, RedPipeItem *item);
/* for types that use this routine -> the pipe item should be freed */
void red_channel_client_pipe_add_type(RedChannelClient *rcc, int pipe_item_type);
void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type);
@@ -619,7 +619,7 @@ void red_client_migrate(RedClient *client);
*/
int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
- PipeItem *item,
+ RedPipeItem *item,
int64_t timeout);
int red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
int64_t timeout);
diff --git a/server/red-pipe-item.c b/server/red-pipe-item.c
index 098f1d4..d9c60aa 100644
--- a/server/red-pipe-item.c
+++ b/server/red-pipe-item.c
@@ -20,9 +20,9 @@
#include "red-channel.h"
#include "red-pipe-item.h"
-PipeItem *pipe_item_ref(gpointer object)
+RedPipeItem *red_pipe_item_ref(gpointer object)
{
- PipeItem *item = object;
+ RedPipeItem *item = object;
g_return_val_if_fail(item->refcount > 0, NULL);
@@ -31,9 +31,9 @@ PipeItem *pipe_item_ref(gpointer object)
return item;
}
-void pipe_item_unref(gpointer object)
+void red_pipe_item_unref(gpointer object)
{
- PipeItem *item = object;
+ RedPipeItem *item = object;
g_return_if_fail(item->refcount > 0);
@@ -42,9 +42,9 @@ void pipe_item_unref(gpointer object)
}
}
-void pipe_item_init_full(PipeItem *item,
- gint type,
- GDestroyNotify free_func)
+void red_pipe_item_init_full(RedPipeItem *item,
+ gint type,
+ GDestroyNotify free_func)
{
ring_item_init(&item->link);
item->type = type;
diff --git a/server/red-pipe-item.h b/server/red-pipe-item.h
index 4333e19..8bb12b7 100644
--- a/server/red-pipe-item.h
+++ b/server/red-pipe-item.h
@@ -28,19 +28,19 @@ typedef struct {
int refcount;
GDestroyNotify free_func;
-} PipeItem;
+} RedPipeItem;
-void pipe_item_init_full(PipeItem *item, int type, GDestroyNotify free_func);
-PipeItem *pipe_item_ref(gpointer item);
-void pipe_item_unref(gpointer item);
+void red_pipe_item_init_full(RedPipeItem *item, int type, GDestroyNotify free_func);
+RedPipeItem *red_pipe_item_ref(gpointer item);
+void red_pipe_item_unref(gpointer item);
-static inline int pipe_item_is_linked(PipeItem *item)
+static inline int red_pipe_item_is_linked(RedPipeItem *item)
{
return ring_item_is_linked(&item->link);
}
-static inline void pipe_item_init(PipeItem *item, int type)
+static inline void red_pipe_item_init(RedPipeItem *item, int type)
{
- pipe_item_init_full(item, type, NULL);
+ red_pipe_item_init_full(item, type, NULL);
}
#endif
diff --git a/server/red-worker.h b/server/red-worker.h
index 15cceb8..731afc7 100644
--- a/server/red-worker.h
+++ b/server/red-worker.h
@@ -57,7 +57,7 @@ enum {
};
typedef struct VerbItem {
- PipeItem base;
+ RedPipeItem base;
uint16_t verb;
} VerbItem;
@@ -70,7 +70,7 @@ static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
{
VerbItem *item = spice_new(VerbItem, 1);
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
item->verb = verb;
red_channel_client_pipe_add(rcc, &item->base);
}
diff --git a/server/reds.c b/server/reds.c
index a31e38f..51ee331 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -167,7 +167,7 @@ struct ChannelSecurityOptions {
};
typedef struct VDIReadBuf {
- PipeItem parent;
+ RedPipeItem parent;
RedCharDeviceVDIPort *dev;
int len;
@@ -482,7 +482,7 @@ static void reds_reset_vdp(RedsState *reds)
dev->priv->receive_len = sizeof(dev->priv->vdi_chunk_header);
dev->priv->message_receive_len = 0;
if (dev->priv->current_read_buf) {
- pipe_item_unref(dev->priv->current_read_buf);
+ red_pipe_item_unref(dev->priv->current_read_buf);
dev->priv->current_read_buf = NULL;
}
/* Reset read filter to start with clean state when the agent reconnects */
@@ -705,7 +705,7 @@ static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
VDIReadBuf *buf = (VDIReadBuf *)opaque;
- pipe_item_unref(buf);
+ red_pipe_item_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
@@ -744,8 +744,8 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
/* Bogus pipe item type, we only need the RingItem and refcounting
* from the base class and are not going to use the type
*/
- pipe_item_init_full(&buf->parent, -1,
- (GDestroyNotify)vdi_port_read_buf_free);
+ red_pipe_item_init_full(&buf->parent, -1,
+ (GDestroyNotify)vdi_port_read_buf_free);
}
static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
@@ -782,8 +782,8 @@ static void vdi_port_read_buf_free(VDIReadBuf *buf)
/* reads from the device till completes reading a message that is addressed to the client,
* or otherwise, when reading from the device fails */
-static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
- void *opaque)
+static RedPipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
+ void *opaque)
{
RedsState *reds;
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
@@ -843,12 +843,12 @@ static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
dev->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
}
if (vdi_port_read_buf_process(reds->agent_dev, dispatch_buf, &error)) {
- return (PipeItem *)dispatch_buf;
+ return (RedPipeItem *)dispatch_buf;
} else {
if (error) {
reds_agent_remove(reds);
}
- pipe_item_unref(dispatch_buf);
+ red_pipe_item_unref(dispatch_buf);
}
}
} /* END switch */
@@ -857,13 +857,13 @@ static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
}
/* after calling this, we unref the message, and the ref is in the instance side */
-static void vdi_port_send_msg_to_client(PipeItem *msg,
+static void vdi_port_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
- pipe_item_ref(agent_data_buf);
+ red_pipe_item_ref(agent_data_buf);
main_channel_client_push_agent_data(red_client_get_main(client),
agent_data_buf->data,
agent_data_buf->len,
@@ -1218,7 +1218,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
if (error) {
reds_agent_remove(reds);
}
- pipe_item_unref(read_buf);
+ red_pipe_item_unref(read_buf);
}
spice_assert(agent_dev->priv->receive_len);
@@ -4297,7 +4297,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort *self)
/* This ensures the newly created buffer is placed in the
* RedCharDeviceVDIPort::read_bufs queue ready to be reused
*/
- pipe_item_unref(buf);
+ red_pipe_item_unref(buf);
}
}
diff --git a/server/smartcard.c b/server/smartcard.c
index b9b8967..75c5dd2 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -83,19 +83,19 @@ enum {
};
typedef struct ErrorItem {
- PipeItem base;
+ RedPipeItem base;
VSCMsgHeader vheader;
VSCMsgError error;
} ErrorItem;
typedef struct MsgItem {
- PipeItem base;
+ RedPipeItem base;
VSCMsgHeader* vheader;
} MsgItem;
static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
-static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item);
+static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
typedef struct SmartCardChannel {
RedChannel base;
@@ -129,8 +129,8 @@ static void smartcard_read_buf_prepare(RedCharDeviceSmartcard *dev, VSCMsgHeader
}
}
-static PipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
- void *opaque)
+static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
+ void *opaque)
{
RedCharDeviceSmartcard *dev = opaque;
SpiceCharDeviceInterface *sif = spice_char_device_get_interface(sin);
@@ -160,19 +160,19 @@ static PipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
dev->priv->buf_pos = dev->priv->buf;
dev->priv->buf_used = remaining;
if (msg_to_client) {
- return (PipeItem *)msg_to_client;
+ return (RedPipeItem *)msg_to_client;
}
}
return NULL;
}
-static void smartcard_send_msg_to_client(PipeItem *msg,
+static void smartcard_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
RedCharDeviceSmartcard *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);
+ smartcard_channel_client_pipe_add_push(&dev->priv->scc->base, (RedPipeItem *)msg);
}
@@ -427,7 +427,7 @@ static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
}
static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *m,
- PipeItem *item, VSCMsgHeader *vheader)
+ RedPipeItem *item, VSCMsgHeader *vheader)
{
spice_assert(rcc);
spice_assert(vheader);
@@ -439,7 +439,7 @@ static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *
}
static void smartcard_channel_send_error(
- RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item)
+ RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
{
ErrorItem* error_item = (ErrorItem*)item;
@@ -447,7 +447,7 @@ static void smartcard_channel_send_error(
}
static void smartcard_channel_send_msg(RedChannelClient *rcc,
- SpiceMarshaller *m, PipeItem *item)
+ SpiceMarshaller *m, RedPipeItem *item)
{
MsgItem* msg_item = (MsgItem*)item;
@@ -455,7 +455,7 @@ static void smartcard_channel_send_msg(RedChannelClient *rcc,
}
static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
- SpiceMarshaller *m, PipeItem *item)
+ SpiceMarshaller *m, RedPipeItem *item)
{
SmartCardChannelClient *scc;
RedCharDeviceSmartcard *dev;
@@ -483,7 +483,7 @@ static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
}
}
-static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem *item)
+static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@@ -506,10 +506,10 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem *item)
}
static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *item, int item_pushed)
+ RedPipeItem *item, int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
- pipe_item_unref(item);
+ red_pipe_item_unref(item);
} else {
free(item);
}
@@ -530,7 +530,8 @@ static void smartcard_channel_on_disconnect(RedChannelClient *rcc)
/* 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. */
-static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item)
+static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
+ RedPipeItem *item)
{
red_channel_client_pipe_add_push(rcc, item);
}
@@ -539,7 +540,7 @@ static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCE
{
ErrorItem *error_item = spice_new0(ErrorItem, 1);
- pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
+ red_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;
@@ -559,8 +560,8 @@ static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *
{
MsgItem *msg_item = spice_new0(MsgItem, 1);
- pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
- (GDestroyNotify)smartcard_free_vsc_msg_item);
+ red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
+ (GDestroyNotify)smartcard_free_vsc_msg_item);
msg_item->vheader = vheader;
return msg_item;
}
@@ -747,7 +748,8 @@ static int smartcard_channel_handle_message(RedChannelClient *rcc,
return TRUE;
}
-static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc,
+ RedPipeItem *item)
{
}
diff --git a/server/spicevmc.c b/server/spicevmc.c
index aa6a0ed..8450f19 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -43,7 +43,7 @@
#define BUF_SIZE (64 * 1024 + 32)
typedef struct SpiceVmcPipeItem {
- PipeItem base;
+ RedPipeItem base;
/* writes which don't fit this will get split, this is not a problem */
uint8_t buf[BUF_SIZE];
@@ -88,13 +88,13 @@ static RedCharDevice *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc, RED_TYPE_CHAR_DEVICE)
typedef struct PortInitPipeItem {
- PipeItem base;
+ RedPipeItem base;
char* name;
uint8_t opened;
} PortInitPipeItem;
typedef struct PortEventPipeItem {
- PipeItem base;
+ RedPipeItem base;
uint8_t event;
} PortEventPipeItem;
@@ -105,8 +105,8 @@ enum {
PIPE_ITEM_TYPE_PORT_EVENT,
};
-static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
- void *opaque)
+static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
+ void *opaque)
{
SpiceVmcState *state = opaque;
SpiceCharDeviceInterface *sif;
@@ -121,7 +121,7 @@ static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
if (!state->pipe_item) {
msg_item = spice_new0(SpiceVmcPipeItem, 1);
- pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
+ red_pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
} else {
spice_assert(state->pipe_item->buf_used == 0);
msg_item = state->pipe_item;
@@ -133,14 +133,14 @@ static PipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
if (n > 0) {
spice_debug("read from dev %d", n);
msg_item->buf_used = n;
- return (PipeItem *)msg_item;
+ return (RedPipeItem *)msg_item;
} else {
state->pipe_item = msg_item;
return NULL;
}
}
-static void spicevmc_chardev_send_msg_to_client(PipeItem *msg,
+static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
@@ -148,8 +148,8 @@ static void spicevmc_chardev_send_msg_to_client(PipeItem *msg,
SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
spice_assert(state->rcc->client == client);
- pipe_item_ref(vmc_msg);
- red_channel_client_pipe_add_push(state->rcc, (PipeItem *)vmc_msg);
+ red_pipe_item_ref(vmc_msg);
+ red_channel_client_pipe_add_push(state->rcc, (RedPipeItem *)vmc_msg);
}
static void spicevmc_port_send_init(RedChannelClient *rcc)
@@ -158,7 +158,7 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
SpiceCharDeviceInstance *sin = state->chardev_sin;
PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
item->name = strdup(sin->portname);
item->opened = state->port_opened;
red_channel_client_pipe_add_push(rcc, &item->base);
@@ -168,7 +168,7 @@ static void spicevmc_port_send_event(RedChannelClient *rcc, uint8_t event)
{
PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
- pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
+ red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
item->event = event;
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -360,14 +360,14 @@ static void spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
}
static void spicevmc_red_channel_hold_pipe_item(RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
/* NOOP */
}
static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
@@ -377,7 +377,7 @@ static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceVmcState *state;
@@ -391,7 +391,7 @@ static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
SpiceMsgPortInit init;
@@ -405,7 +405,7 @@ static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
SpiceMarshaller *m,
- PipeItem *item)
+ RedPipeItem *item)
{
PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem, base);
SpiceMsgPortEvent event;
@@ -416,7 +416,7 @@ static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
}
static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
- PipeItem *item)
+ RedPipeItem *item)
{
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
@@ -442,10 +442,11 @@ static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
}
static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *item, int item_pushed)
+ RedPipeItem *item,
+ int item_pushed)
{
if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
- pipe_item_unref(item);
+ red_pipe_item_unref(item);
} else {
free(item);
}
diff --git a/server/stream.c b/server/stream.c
index 22e1004..47f6a99 100644
--- a/server/stream.c
+++ b/server/stream.c
@@ -78,7 +78,7 @@ void stream_stop(DisplayChannel *display, Stream *stream)
stream_agent = &dcc->stream_agents[get_stream_id(display, stream)];
region_clear(&stream_agent->vis_region);
region_clear(&stream_agent->clip);
- spice_assert(!pipe_item_is_linked(&stream_agent->destroy_item));
+ spice_assert(!red_pipe_item_is_linked(&stream_agent->destroy_item));
if (stream_agent->mjpeg_encoder && dcc->use_mjpeg_encoder_rate_control) {
uint64_t stream_bit_rate = mjpeg_encoder_get_bit_rate(stream_agent->mjpeg_encoder);
@@ -148,8 +148,8 @@ void stream_clip_item_free(StreamClipItem *item)
StreamClipItem *stream_clip_item_new(StreamAgent *agent)
{
StreamClipItem *item = spice_new(StreamClipItem, 1);
- pipe_item_init_full((PipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
- (GDestroyNotify)stream_clip_item_free);
+ red_pipe_item_init_full((RedPipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
+ (GDestroyNotify)stream_clip_item_free);
item->stream_agent = agent;
agent->stream->refs++;
@@ -343,7 +343,7 @@ static void before_reattach_stream(DisplayChannel *display,
continue;
}
- if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
+ if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
#ifdef STREAM_STATS
agent->stats.num_drops_pipe++;
#endif
@@ -734,8 +734,8 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
StreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
agent->report_id = rand();
- pipe_item_init(&report_pipe_item->pipe_item,
- PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
+ red_pipe_item_init(&report_pipe_item->pipe_item,
+ PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &report_pipe_item->pipe_item);
}
@@ -808,8 +808,8 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
upgrade_item = spice_new(UpgradeItem, 1);
- pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
- (GDestroyNotify)upgrade_item_free);
+ red_pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
+ (GDestroyNotify)upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
n_rects = pixman_region32_n_rects(&upgrade_item->drawable->tree_item.base.rgn);
diff --git a/server/stream.h b/server/stream.h
index c83e3b5..5b59212 100644
--- a/server/stream.h
+++ b/server/stream.h
@@ -47,7 +47,7 @@ typedef struct DisplayChannel DisplayChannel;
typedef struct Stream Stream;
typedef struct StreamActivateReportItem {
- PipeItem pipe_item;
+ RedPipeItem pipe_item;
uint32_t stream_id;
} StreamActivateReportItem;
@@ -81,8 +81,8 @@ typedef struct StreamAgent {
vis_region will contain c2 and also the part of c1/c2 that still
displays fragments of the video */
- PipeItem create_item;
- PipeItem destroy_item;
+ RedPipeItem create_item;
+ RedPipeItem destroy_item;
Stream *stream;
uint64_t last_send_time;
MJpegEncoder *mjpeg_encoder;
@@ -100,7 +100,7 @@ typedef struct StreamAgent {
} StreamAgent;
typedef struct StreamClipItem {
- PipeItem base;
+ RedPipeItem base;
StreamAgent *stream_agent;
int clip_type;
SpiceClipRects *rects;
commit 64dc3ab244969ddf6abee3bf92a2f29225999e5e
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Apr 7 17:11:27 2016 -0500
Use weak gobject ref instead of reds_on_char_device_state_destroy
RedCharDevice implementation had to callback into reds.c in order to let
it know a char device was being destroyed. Now that RedCharDevice is a
gobject, a weak reference can be used instead allowing to remove that
coupling.
Acked-by: Jonathon Jongsma <jjongsma at redhat.com>
diff --git a/server/char-device.c b/server/char-device.c
index 445658d..6cb6864 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -1111,8 +1111,6 @@ red_char_device_finalize(GObject *object)
{
RedCharDevice *self = RED_CHAR_DEVICE(object);
- /* FIXME: replace with g_object_weak_ref () */
- reds_on_char_device_state_destroy(self->priv->reds, self);
if (self->priv->write_to_dev_timer) {
reds_core_timer_remove(self->priv->reds, self->priv->write_to_dev_timer);
self->priv->write_to_dev_timer = NULL;
diff --git a/server/reds.c b/server/reds.c
index 440f70e..a31e38f 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -252,7 +252,6 @@ static void reds_mig_target_client_free(RedsMigTargetClient *mig_client);
static void reds_mig_cleanup_wait_disconnect(RedsState *reds);
static void reds_mig_remove_wait_disconnect_client(RedsState *reds, RedClient *client);
static void reds_add_char_device(RedsState *reds, RedCharDevice *dev);
-static void reds_remove_char_device(RedsState *reds, RedCharDevice *dev);
static void reds_send_mm_time(RedsState *reds);
static void reds_on_ic_change(RedsState *reds);
static void reds_on_sv_change(RedsState *reds);
@@ -3142,15 +3141,13 @@ static void reds_add_char_device(RedsState *reds, RedCharDevice *dev)
reds->char_devices = g_list_append(reds->char_devices, dev);
}
-static void reds_remove_char_device(RedsState *reds, RedCharDevice *dev)
+static void reds_on_char_device_destroy(RedsState *reds,
+ RedCharDevice *dev)
{
+ g_return_if_fail(reds != NULL);
g_warn_if_fail(g_list_find(reds->char_devices, dev) != NULL);
- reds->char_devices = g_list_remove(reds->char_devices, dev);
-}
-void reds_on_char_device_state_destroy(RedsState *reds, RedCharDevice *dev)
-{
- reds_remove_char_device(reds, dev);
+ reds->char_devices = g_list_remove(reds->char_devices, dev);
}
static int spice_server_char_device_add_interface(SpiceServer *reds,
@@ -3188,6 +3185,10 @@ static int spice_server_char_device_add_interface(SpiceServer *reds,
if (dev_state) {
spice_assert(char_device->st);
+
+ g_object_weak_ref(G_OBJECT(dev_state),
+ (GWeakNotify)reds_on_char_device_destroy,
+ reds);
/* setting the char_device state to "started" for backward compatibily with
* qemu releases that don't call spice api for start/stop (not implemented yet) */
if (reds->vm_running) {
diff --git a/server/reds.h b/server/reds.h
index 2cfd451..5b33432 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -100,7 +100,6 @@ int reds_on_migrate_dst_set_seamless(RedsState *reds, MainChannelClient *mcc, ui
void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *client);
void reds_on_client_seamless_migrate_complete(RedsState *reds, RedClient *client);
void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc);
-void reds_on_char_device_state_destroy(RedsState *reds, RedCharDevice *dev);
void reds_set_client_mm_time_latency(RedsState *reds, RedClient *client, uint32_t latency);
uint32_t reds_get_streaming_video(const RedsState *reds);
commit d232e92794c74a326d1e48355d257f24a6d497c2
Author: Christophe Fergeau <cfergeau at redhat.com>
Date: Thu Apr 7 17:11:26 2016 -0500
Use GQueue for RedCharDevice::send_queue
There was an extra RedCharDeviceMsgToClientItem type whose only
purpose was to manage a linked list of items to send. GQueue has the
same purpose as this type in addition to being generic. As the length of
the send queue is tracked, a GQueue is more appropriate than a GList and
allow to remove RedCharDevice::send_queue_size.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/char-device.c b/server/char-device.c
index 0495cc2..445658d 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -41,8 +41,7 @@ struct RedCharDeviceClient {
uint64_t num_send_tokens; /* send to client */
SpiceTimer *wait_for_tokens_timer;
int wait_for_tokens_started;
- Ring send_queue;
- uint32_t send_queue_size;
+ GQueue *send_queue;
uint32_t max_send_queue_size;
};
@@ -97,11 +96,6 @@ enum {
static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_buf);
static void red_char_device_write_retry(void *opaque);
-typedef struct RedCharDeviceMsgToClientItem {
- RingItem link;
- PipeItem *msg;
-} RedCharDeviceMsgToClientItem;
-
static PipeItem *
red_char_device_read_one_msg_from_device(RedCharDevice *dev)
{
@@ -186,24 +180,6 @@ static void red_char_device_write_buffer_pool_add(RedCharDevice *dev,
red_char_device_write_buffer_unref(buf);
}
-static void red_char_device_client_send_queue_free(RedCharDevice *dev,
- RedCharDeviceClient *dev_client)
-{
- spice_debug("send_queue_empty %d", ring_is_empty(&dev_client->send_queue));
- while (!ring_is_empty(&dev_client->send_queue)) {
- RingItem *item = ring_get_tail(&dev_client->send_queue);
- RedCharDeviceMsgToClientItem *msg_item = SPICE_CONTAINEROF(item,
- RedCharDeviceMsgToClientItem,
- link);
-
- ring_remove(item);
- pipe_item_unref(msg_item->msg);
- free(msg_item);
- }
- dev_client->num_send_tokens += dev_client->send_queue_size;
- dev_client->send_queue_size = 0;
-}
-
static void red_char_device_client_free(RedCharDevice *dev,
RedCharDeviceClient *dev_client)
{
@@ -214,7 +190,7 @@ static void red_char_device_client_free(RedCharDevice *dev,
dev_client->wait_for_tokens_timer = NULL;
}
- red_char_device_client_send_queue_free(dev, dev_client);
+ g_queue_free_full(dev_client->send_queue, pipe_item_unref);
/* remove write buffers that are associated with the client */
spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->priv->write_queue) && !dev->priv->cur_write_buf);
@@ -305,17 +281,14 @@ static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
PipeItem *msg)
{
RedCharDevice *dev = dev_client->dev;
- RedCharDeviceMsgToClientItem *msg_item;
- if (dev_client->send_queue_size >= dev_client->max_send_queue_size) {
+ if (g_queue_get_length(dev_client->send_queue) >= dev_client->max_send_queue_size) {
red_char_device_handle_client_overflow(dev_client);
return;
}
- msg_item = spice_new0(RedCharDeviceMsgToClientItem, 1);
- msg_item->msg = pipe_item_ref(msg);
- ring_add(&dev_client->send_queue, &msg_item->link);
- dev_client->send_queue_size++;
+ pipe_item_ref(msg);
+ g_queue_push_head(dev_client->send_queue, msg);
if (!dev_client->wait_for_tokens_started) {
reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
@@ -334,7 +307,7 @@ static void red_char_device_send_msg_to_clients(RedCharDevice *dev,
dev_client = SPICE_CONTAINEROF(item, RedCharDeviceClient, link);
if (red_char_device_can_send_to_client(dev_client)) {
dev_client->num_send_tokens--;
- spice_assert(ring_is_empty(&dev_client->send_queue));
+ spice_assert(g_queue_is_empty(dev_client->send_queue));
red_char_device_send_msg_to_client(dev, msg, dev_client->client);
/* don't refer to dev_client anymore, it may have been released */
@@ -396,21 +369,14 @@ static int red_char_device_read_from_device(RedCharDevice *dev)
static void red_char_device_client_send_queue_push(RedCharDeviceClient *dev_client)
{
- RingItem *item;
- while ((item = ring_get_tail(&dev_client->send_queue)) &&
+ while (!g_queue_is_empty(dev_client->send_queue) &&
red_char_device_can_send_to_client(dev_client)) {
- RedCharDeviceMsgToClientItem *msg_item;
-
- msg_item = SPICE_CONTAINEROF(item, RedCharDeviceMsgToClientItem, link);
- ring_remove(item);
-
+ PipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
+ g_assert(msg != NULL);
dev_client->num_send_tokens--;
- red_char_device_send_msg_to_client(dev_client->dev,
- msg_item->msg,
+ red_char_device_send_msg_to_client(dev_client->dev, msg,
dev_client->client);
- pipe_item_unref(msg_item->msg);
- dev_client->send_queue_size--;
- free(msg_item);
+ pipe_item_unref(msg);
}
}
@@ -420,7 +386,7 @@ static void red_char_device_send_to_client_tokens_absorb(RedCharDeviceClient *de
RedCharDevice *dev = dev_client->dev;
dev_client->num_send_tokens += tokens;
- if (dev_client->send_queue_size) {
+ if (g_queue_get_length(dev_client->send_queue)) {
spice_assert(dev_client->num_send_tokens == tokens);
red_char_device_client_send_queue_push(dev_client);
}
@@ -429,7 +395,7 @@ static void red_char_device_send_to_client_tokens_absorb(RedCharDeviceClient *de
reds_core_timer_cancel(dev->priv->reds, dev_client->wait_for_tokens_timer);
dev_client->wait_for_tokens_started = FALSE;
red_char_device_read_from_device(dev_client->dev);
- } else if (dev_client->send_queue_size) {
+ } else if (!g_queue_is_empty(dev_client->send_queue)) {
reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
dev_client->wait_for_tokens_started = TRUE;
@@ -750,8 +716,7 @@ static RedCharDeviceClient *red_char_device_client_new(RedClient *client,
dev_client = spice_new0(RedCharDeviceClient, 1);
dev_client->client = client;
- ring_init(&dev_client->send_queue);
- dev_client->send_queue_size = 0;
+ dev_client->send_queue = g_queue_new();
dev_client->max_send_queue_size = max_send_queue_size;
dev_client->do_flow_control = do_flow_control;
if (do_flow_control) {
@@ -884,7 +849,10 @@ void red_char_device_reset(RedCharDevice *dev)
RedCharDeviceClient *dev_client;
dev_client = SPICE_CONTAINEROF(client_item, RedCharDeviceClient, link);
- red_char_device_client_send_queue_free(dev, dev_client);
+ spice_debug("send_queue_empty %d", g_queue_is_empty(dev_client->send_queue));
+ dev_client->num_send_tokens += g_queue_get_length(dev_client->send_queue);
+ g_queue_foreach(dev_client->send_queue, (GFunc)pipe_item_unref, NULL);
+ g_queue_clear(dev_client->send_queue);
}
red_char_device_reset_dev_instance(dev, NULL);
}
@@ -933,9 +901,9 @@ void red_char_device_migrate_data_marshall(RedCharDevice *dev,
RedCharDeviceClient,
link);
/* FIXME: if there were more than one client before the marshalling,
- * it is possible that the send_queue_size > 0, and the send data
+ * it is possible that the send_queue length > 0, and the send data
* should be migrated as well */
- spice_assert(dev_client->send_queue_size == 0);
+ spice_assert(g_queue_is_empty(dev_client->send_queue));
spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION);
spice_marshaller_add_uint8(m, 1); /* connected */
spice_marshaller_add_uint32(m, dev_client->num_client_tokens);
commit 18d3876b78c7f19c577da000d322dbd44e63e456
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Apr 14 16:12:50 2016 -0500
UpgradeItem: use base PipeItem for refcounting
No need to re-implement refcounting in this subclass.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/dcc.c b/server/dcc.c
index d52d2e4..4fe7652 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -1589,16 +1589,6 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
return TRUE;
}
-static void upgrade_item_unref(UpgradeItem *item)
-{
- if (--item->refs != 0)
- return;
-
- drawable_unref(item->drawable);
- free(item->rects);
- free(item);
-}
-
static void release_item_after_push(PipeItem *item)
{
switch (item->type) {
@@ -1606,10 +1596,8 @@ static void release_item_after_push(PipeItem *item)
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
- pipe_item_unref(item);
- break;
case PIPE_ITEM_TYPE_UPGRADE:
- upgrade_item_unref((UpgradeItem *)item);
+ pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
@@ -1647,8 +1635,6 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
}
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
- upgrade_item_unref((UpgradeItem *)item);
- break;
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
pipe_item_unref(item);
diff --git a/server/display-channel.c b/server/display-channel.c
index c53c095..93c111b 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -1971,10 +1971,8 @@ static void hold_item(RedChannelClient *rcc, PipeItem *item)
case PIPE_ITEM_TYPE_DRAW:
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_STREAM_CLIP:
- pipe_item_ref(item);
- break;
case PIPE_ITEM_TYPE_UPGRADE:
- ((UpgradeItem *)item)->refs++;
+ pipe_item_ref(item);
break;
default:
spice_warn_if_reached();
diff --git a/server/display-channel.h b/server/display-channel.h
index 3752c62..1ccedaf 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -247,7 +247,6 @@ typedef struct SurfaceDestroyItem {
typedef struct UpgradeItem {
PipeItem base;
- int refs;
Drawable *drawable;
SpiceClipRects *rects;
} UpgradeItem;
diff --git a/server/stream.c b/server/stream.c
index ae37a62..22e1004 100644
--- a/server/stream.c
+++ b/server/stream.c
@@ -758,6 +758,16 @@ void stream_agent_stop(StreamAgent *agent)
}
}
+static void upgrade_item_free(UpgradeItem *item)
+{
+ g_return_if_fail(item != NULL);
+ g_return_if_fail(item->base.refcount != 0);
+
+ drawable_unref(item->drawable);
+ free(item->rects);
+ free(item);
+}
+
/*
* after dcc_detach_stream_gracefully is called for all the display channel clients,
* detach_stream should be called. See comment (1).
@@ -798,8 +808,8 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
upgrade_item = spice_new(UpgradeItem, 1);
- upgrade_item->refs = 1;
- pipe_item_init(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE);
+ pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
+ (GDestroyNotify)upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
n_rects = pixman_region32_n_rects(&upgrade_item->drawable->tree_item.base.rgn);
commit 50a2c2fce213e97a6d91a48737a3698946e972a5
Author: Jonathon Jongsma <jjongsma at redhat.com>
Date: Thu Apr 21 10:45:15 2016 -0500
Store display in Drawable struct
If the Drawable keeps a pointer to the Display channel that it is
associated with, we can unref it directly and not need to pass the
'display' parameter separately to the unref function
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/dcc.c b/server/dcc.c
index 91c3f82..d52d2e4 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -277,13 +277,11 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
void drawable_pipe_item_free(PipeItem *item)
{
DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
- DisplayChannel *display = DCC_TO_DC(dpi->dcc);
-
spice_assert(item->refcount == 0);
spice_warn_if_fail(!ring_item_is_linked(&item->link));
spice_warn_if_fail(!ring_item_is_linked(&dpi->base));
- display_channel_drawable_unref(display, dpi->drawable);
+ drawable_unref(dpi->drawable);
free(dpi);
}
@@ -1591,20 +1589,18 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
return TRUE;
}
-static void upgrade_item_unref(DisplayChannel *display, UpgradeItem *item)
+static void upgrade_item_unref(UpgradeItem *item)
{
if (--item->refs != 0)
return;
- display_channel_drawable_unref(display, item->drawable);
+ drawable_unref(item->drawable);
free(item->rects);
free(item);
}
-static void release_item_after_push(DisplayChannelClient *dcc, PipeItem *item)
+static void release_item_after_push(PipeItem *item)
{
- DisplayChannel *display = DCC_TO_DC(dcc);
-
switch (item->type) {
case PIPE_ITEM_TYPE_DRAW:
case PIPE_ITEM_TYPE_IMAGE:
@@ -1613,7 +1609,7 @@ static void release_item_after_push(DisplayChannelClient *dcc, PipeItem *item)
pipe_item_unref(item);
break;
case PIPE_ITEM_TYPE_UPGRADE:
- upgrade_item_unref(display, (UpgradeItem *)item);
+ upgrade_item_unref((UpgradeItem *)item);
break;
case PIPE_ITEM_TYPE_GL_SCANOUT:
case PIPE_ITEM_TYPE_GL_DRAW:
@@ -1651,7 +1647,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
}
case PIPE_ITEM_TYPE_STREAM_CLIP:
case PIPE_ITEM_TYPE_UPGRADE:
- upgrade_item_unref(display, (UpgradeItem *)item);
+ upgrade_item_unref((UpgradeItem *)item);
break;
case PIPE_ITEM_TYPE_IMAGE:
case PIPE_ITEM_TYPE_MONITORS_CONFIG:
@@ -1688,7 +1684,7 @@ static void release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
void dcc_release_item(DisplayChannelClient *dcc, PipeItem *item, int item_pushed)
{
if (item_pushed)
- release_item_after_push(dcc, item);
+ release_item_after_push(item);
else
release_item_before_push(dcc, item);
}
diff --git a/server/display-channel.c b/server/display-channel.c
index abc94d5..c53c095 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -390,7 +390,7 @@ static void current_remove_drawable(DisplayChannel *display, Drawable *item)
ring_remove(&item->tree_item.base.siblings_link);
ring_remove(&item->list_link);
ring_remove(&item->surface_list_link);
- display_channel_drawable_unref(display, item);
+ drawable_unref(item);
display->current_size--;
}
@@ -488,7 +488,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
pipes_add_drawable(display, drawable);
}
drawable_remove_from_pipes(other_drawable);
- display_channel_drawable_unref(display, other_drawable);
+ drawable_unref(other_drawable);
return TRUE;
}
@@ -531,7 +531,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
/* not sending other_drawable where possible */
drawable_remove_from_pipes(other_drawable);
- display_channel_drawable_unref(display, other_drawable);
+ drawable_unref(other_drawable);
return TRUE;
}
break;
@@ -1185,7 +1185,7 @@ void display_channel_process_draw(DisplayChannel *display, RedDrawable *red_draw
display_channel_add_drawable(display, drawable);
- display_channel_drawable_unref(display, drawable);
+ drawable_unref(drawable);
}
int display_channel_wait_for_migrate_data(DisplayChannel *display)
@@ -1373,6 +1373,10 @@ Drawable *display_channel_drawable_try_new(DisplayChannel *display,
}
bzero(drawable, sizeof(Drawable));
+ /* Pointer to the display from which the drawable is allocated. This
+ * pointer is safe to be retained as DisplayChannel lifespan is bigger than
+ * all drawables. */
+ drawable->display = display;
drawable->refs = 1;
drawable->creation_time = drawable->first_frame_time = spice_get_monotonic_time_ns();
ring_item_init(&drawable->list_link);
@@ -1423,8 +1427,9 @@ static void drawable_unref_surface_deps(DisplayChannel *display, Drawable *drawa
}
}
-void display_channel_drawable_unref(DisplayChannel *display, Drawable *drawable)
+void drawable_unref(Drawable *drawable)
{
+ DisplayChannel *display = drawable->display;
RingItem *item, *next;
if (--drawable->refs != 0)
@@ -1646,7 +1651,7 @@ static void draw_until(DisplayChannel *display, RedSurface *surface, Drawable *l
that display_channel_draw is called for, Otherwise, 'now' would have already been rendered.
See the call for red_handle_depends_on_target_surface in red_process_draw */
drawable_draw(display, now);
- display_channel_drawable_unref(display, now);
+ drawable_unref(now);
} while (now != last);
}
diff --git a/server/display-channel.h b/server/display-channel.h
index d5356fc..3752c62 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -79,8 +79,11 @@ struct Drawable {
int surface_deps[3];
uint32_t process_commands_generation;
+ DisplayChannel *display;
};
+void drawable_unref (Drawable *drawable);
+
#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), DrawablePipeItem, base)
#define DRAWABLE_FOREACH_DPI_SAFE(drawable, link, next, dpi) \
SAFE_FOREACH(link, next, drawable, &(drawable)->pipes, dpi, LINK_TO_DPI(link))
@@ -280,7 +283,6 @@ void display_channel_compress_stats_print (const Disp
void display_channel_compress_stats_reset (DisplayChannel *display);
Drawable * display_channel_drawable_try_new (DisplayChannel *display,
int process_commands_generation);
-void display_channel_drawable_unref (DisplayChannel *display, Drawable *drawable);
void display_channel_surface_unref (DisplayChannel *display,
uint32_t surface_id);
void display_channel_current_flush (DisplayChannel *display,
More information about the Spice-commits
mailing list