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

main-channel-client: Automatically convert

Browse Source 
Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
This commit is contained in:
Frediano Ziglio 2020-03-17 19:11:18 +00:00 committed by Frediano Ziglio
parent 9fd105e925
commit ab7486a9e8
9 changed files with 156 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/common-graphics-channel.cpp
View File

@ -51,7 +51,7 @@ bool CommonGraphicsChannelClient::config_socket()
gboolean is_low_bandwidth;
// TODO - this should be dynamic, not one time at channel creation
is_low_bandwidth = main_channel_client_is_low_bandwidth(mcc);
is_low_bandwidth = mcc->is_low_bandwidth();
if (!red_stream_set_auto_flush(stream, false)) {
/* FIXME: Using Nagle's Algorithm can lead to apparent delays, depending
* on the delayed ack timeout on the other side.

2
server/dcc.cpp
View File

@ -1262,7 +1262,7 @@ bool DisplayChannelClient::config_socket()
RedClient *client = get_client();
MainChannelClient *mcc = client->get_main();
is_low_bandwidth = main_channel_client_is_low_bandwidth(mcc);
is_low_bandwidth = mcc->is_low_bandwidth();
return CommonGraphicsChannelClient::config_socket();
}

3
server/inputs-channel.cpp
View File

@ -446,8 +446,7 @@ void InputsChannel::on_connect(RedClient *client, RedStream *stream, int migrati
RedChannelCapabilities *caps)
{
if (!red_stream_is_ssl(stream) && !client->during_migrate_at_target()) {
main_channel_client_push_notify(client->get_main(),
"keyboard channel is insecure");
client->get_main()->push_notify("keyboard channel is insecure");
}
inputs_channel_client_create(this, client, stream, caps);

175
server/main-channel-client.cpp
View File

@ -218,11 +218,11 @@ static RedPipeItem *main_agent_tokens_item_new(uint32_t num_tokens)
}
void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
void MainChannelClient::push_agent_tokens(uint32_t num_tokens)
{
RedPipeItem *item = main_agent_tokens_item_new(num_tokens);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
static void main_agent_data_item_free(RedPipeItem *base)
@ -247,13 +247,14 @@ static RedPipeItem *main_agent_data_item_new(uint8_t* data, size_t len,
return &item->base;
}
void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data, void *opaque)
void MainChannelClient::push_agent_data(uint8_t *data, size_t len,
spice_marshaller_item_free_func free_data,
void *opaque)
{
RedPipeItem *item;
item = main_agent_data_item_new(data, len, free_data, opaque);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
static RedPipeItem *main_init_item_new(int connection_id,
@ -275,19 +276,17 @@ static RedPipeItem *main_init_item_new(int connection_id,
return &item->base;
}
void main_channel_client_push_init(MainChannelClient *mcc,
int display_channels_hint,
SpiceMouseMode current_mouse_mode,
int is_client_mouse_allowed,
int multi_media_time,
int ram_hint)
void MainChannelClient::push_init(int display_channels_hint,
SpiceMouseMode current_mouse_mode,
int is_client_mouse_allowed,
int multi_media_time, int ram_hint)
{
RedPipeItem *item;
item = main_init_item_new(mcc->priv->connection_id, display_channels_hint,
item = main_init_item_new(priv->connection_id, display_channels_hint,
current_mouse_mode, is_client_mouse_allowed,
multi_media_time, ram_hint);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
static RedPipeItem *main_name_item_new(const char *name)
@ -301,15 +300,15 @@ static RedPipeItem *main_name_item_new(const char *name)
return &item->base;
}
void main_channel_client_push_name(MainChannelClient *mcc, const char *name)
void MainChannelClient::push_name(const char *name)
{
RedPipeItem *item;
if (!mcc->test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
if (!test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
return;
item = main_name_item_new(name);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
static RedPipeItem *main_uuid_item_new(const uint8_t uuid[16])
@ -322,21 +321,21 @@ static RedPipeItem *main_uuid_item_new(const uint8_t uuid[16])
return &item->base;
}
void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
void MainChannelClient::push_uuid(const uint8_t uuid[16])
{
RedPipeItem *item;
if (!mcc->test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
if (!test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
return;
item = main_uuid_item_new(uuid);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
void MainChannelClient::push_notify(const char *msg)
{
RedPipeItem *item = main_notify_item_new(msg, 1);
mcc->pipe_add_push(item);
pipe_add_push(item);
}
RedPipeItem *main_mouse_mode_item_new(SpiceMouseMode current_mode, int is_client_mouse_allowed)
@ -371,32 +370,29 @@ RedPipeItem *registered_channel_item_new(RedChannel *channel)
return &item->base;
}
void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
int success,
int seamless)
void MainChannelClient::handle_migrate_connected(int success, int seamless)
{
if (mcc->priv->mig_wait_connect) {
MainChannel *channel = mcc->get_channel();
if (priv->mig_wait_connect) {
MainChannel *channel = get_channel();
mcc->priv->mig_wait_connect = FALSE;
mcc->priv->mig_connect_ok = success;
priv->mig_wait_connect = FALSE;
priv->mig_connect_ok = success;
channel->on_migrate_connected(success, seamless);
} else {
if (success) {
mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
}
}
}
void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
uint32_t src_version)
void MainChannelClient::handle_migrate_dst_do_seamless(uint32_t src_version)
{
RedChannel *channel = mcc->get_channel();
if (reds_on_migrate_dst_set_seamless(channel->get_server(), mcc, src_version)) {
mcc->priv->seamless_mig_dst = TRUE;
mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
RedChannel *channel = get_channel();
if (reds_on_migrate_dst_set_seamless(channel->get_server(), this, src_version)) {
priv->seamless_mig_dst = TRUE;
pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
} else {
mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
}
}
@ -446,7 +442,7 @@ void MainChannelClient::handle_pong(SpiceMsgPing *ping, uint32_t size)
(double)priv->latency / 1000,
priv->bitrate_per_sec,
(double)priv->bitrate_per_sec / 1024 / 1024,
main_channel_client_is_low_bandwidth(this) ? " LOW BANDWIDTH" : "");
this->is_low_bandwidth() ? " LOW BANDWIDTH" : "");
start_connectivity_monitoring(CLIENT_CONNECTIVITY_TIMEOUT);
break;
default:
@ -459,16 +455,16 @@ void MainChannelClient::handle_pong(SpiceMsgPing *ping, uint32_t size)
}
}
void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
void MainChannelClient::handle_migrate_end()
{
RedClient *client = mcc->get_client();
RedClient *client = get_client();
if (!client->during_migrate_at_target()) {
red_channel_warning(mcc->get_channel(),
red_channel_warning(get_channel(),
"unexpected SPICE_MSGC_MIGRATE_END");
return;
}
if (!mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
red_channel_warning(mcc->get_channel(),
if (!test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
red_channel_warning(get_channel(),
"unexpected SPICE_MSGC_MIGRATE_END, "
"client does not support semi-seamless migration");
return;
@ -476,49 +472,48 @@ void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
client->semi_seamless_migrate_complete();
}
void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc)
void MainChannelClient::migrate_cancel_wait()
{
if (mcc->priv->mig_wait_connect) {
mcc->priv->mig_wait_connect = FALSE;
mcc->priv->mig_connect_ok = FALSE;
if (priv->mig_wait_connect) {
priv->mig_wait_connect = FALSE;
priv->mig_connect_ok = FALSE;
}
mcc->priv->mig_wait_prev_complete = FALSE;
priv->mig_wait_prev_complete = FALSE;
}
void main_channel_client_migrate_dst_complete(MainChannelClient *mcc)
void MainChannelClient::migrate_dst_complete()
{
if (mcc->priv->mig_wait_prev_complete) {
if (mcc->priv->mig_wait_prev_try_seamless) {
RedChannel *channel = mcc->get_channel();
if (priv->mig_wait_prev_complete) {
if (priv->mig_wait_prev_try_seamless) {
RedChannel *channel = get_channel();
spice_assert(channel->get_n_clients() == 1);
mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
} else {
mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
}
mcc->priv->mig_wait_connect = TRUE;
mcc->priv->mig_wait_prev_complete = FALSE;
priv->mig_wait_connect = TRUE;
priv->mig_wait_prev_complete = FALSE;
}
}
gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
gboolean success)
gboolean MainChannelClient::migrate_src_complete(gboolean success)
{
gboolean ret = FALSE;
bool semi_seamless_support = mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
if (semi_seamless_support && mcc->priv->mig_connect_ok) {
bool semi_seamless_support = test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
if (semi_seamless_support && priv->mig_connect_ok) {
if (success) {
mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_END);
pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_END);
ret = TRUE;
} else {
mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
}
} else {
if (success) {
mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
}
mcc->priv->mig_connect_ok = FALSE;
mcc->priv->mig_wait_connect = FALSE;
priv->mig_connect_ok = FALSE;
priv->mig_wait_connect = FALSE;
return ret;
}
@ -546,25 +541,25 @@ MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient
return mcc;
}
int main_channel_client_is_network_info_initialized(MainChannelClient *mcc)
int MainChannelClient::is_network_info_initialized()
{
return mcc->priv->net_test_stage == NET_TEST_STAGE_COMPLETE;
return priv->net_test_stage == NET_TEST_STAGE_COMPLETE;
}
int main_channel_client_is_low_bandwidth(MainChannelClient *mcc)
int MainChannelClient::is_low_bandwidth()
{
// TODO: configurable?
return mcc->priv->bitrate_per_sec < 10 * 1024 * 1024;
return priv->bitrate_per_sec < 10 * 1024 * 1024;
}
uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc)
uint64_t MainChannelClient::get_bitrate_per_sec()
{
return mcc->priv->bitrate_per_sec;
return priv->bitrate_per_sec;
}
uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc)
uint64_t MainChannelClient::get_roundtrip_ms()
{
return mcc->priv->latency / 1000;
return priv->latency / 1000;
}
void MainChannelClient::migrate()
@ -574,40 +569,40 @@ void MainChannelClient::migrate()
RedChannelClient::migrate();
}
gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
gboolean MainChannelClient::connect_semi_seamless()
{
if (mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
RedClient *client = mcc->get_client();
if (test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
RedClient *client = get_client();
if (client->during_migrate_at_target()) {
mcc->priv->mig_wait_prev_complete = TRUE;
mcc->priv->mig_wait_prev_try_seamless = FALSE;
priv->mig_wait_prev_complete = TRUE;
priv->mig_wait_prev_try_seamless = FALSE;
} else {
mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
mcc->priv->mig_wait_connect = TRUE;
pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
priv->mig_wait_connect = TRUE;
}
mcc->priv->mig_connect_ok = FALSE;
priv->mig_connect_ok = FALSE;
return TRUE;
}
return FALSE;
}
void main_channel_client_connect_seamless(MainChannelClient *mcc)
void MainChannelClient::connect_seamless()
{
RedClient *client = mcc->get_client();
spice_assert(mcc->test_remote_cap(SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
RedClient *client = get_client();
spice_assert(test_remote_cap(SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
if (client->during_migrate_at_target()) {
mcc->priv->mig_wait_prev_complete = TRUE;
mcc->priv->mig_wait_prev_try_seamless = TRUE;
priv->mig_wait_prev_complete = TRUE;
priv->mig_wait_prev_try_seamless = TRUE;
} else {
mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
mcc->priv->mig_wait_connect = TRUE;
pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
priv->mig_wait_connect = TRUE;
}
mcc->priv->mig_connect_ok = FALSE;
priv->mig_connect_ok = FALSE;
}
uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc)
uint32_t MainChannelClient::get_connection_id()
{
return mcc->priv->connection_id;
return priv->connection_id;
}
static uint32_t main_channel_client_next_ping_id(MainChannelClient *mcc)

82
server/main-channel-client.h
View File

@ -26,11 +26,48 @@
#include "push-visibility.h"
struct MainChannelClientPrivate;
class MainChannelClientPrivate;
MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
RedStream *stream, uint32_t connection_id,
RedChannelCapabilities *caps);
class MainChannelClient final: public RedChannelClient
{
public:
void push_agent_tokens(uint32_t num_tokens);
void push_agent_data(uint8_t *data, size_t len,
spice_marshaller_item_free_func free_data, void *opaque);
// TODO: huge. Consider making a reds_* interface for these functions
// and calling from main.
void push_init(int display_channels_hint, SpiceMouseMode current_mouse_mode,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint);
void push_notify(const char *msg);
gboolean connect_semi_seamless();
void connect_seamless();
void handle_migrate_connected(int success, int seamless);
void handle_migrate_dst_do_seamless(uint32_t src_version);
void handle_migrate_end();
void migrate_cancel_wait();
void migrate_dst_complete();
gboolean migrate_src_complete(gboolean success);
/*
* return TRUE if network test had been completed successfully.
* If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
*/
int is_network_info_initialized();
int is_low_bandwidth();
uint64_t get_bitrate_per_sec();
uint64_t get_roundtrip_ms();
void push_name(const char *name);
void push_uuid(const uint8_t uuid[16]);
uint32_t get_connection_id();
MainChannelClient(MainChannel *channel,
RedClient *client,
RedStream *stream,
@ -58,49 +95,6 @@ public:
red::unique_link<MainChannelClientPrivate> priv;
};
MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
RedStream *stream, uint32_t connection_id,
RedChannelCapabilities *caps);
void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens);
void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
spice_marshaller_item_free_func free_data, void *opaque);
// TODO: huge. Consider making a reds_* interface for these functions
// and calling from main.
void main_channel_client_push_init(MainChannelClient *mcc,
int display_channels_hint,
SpiceMouseMode current_mouse_mode,
int is_client_mouse_allowed,
int multi_media_time,
int ram_hint);
void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg);
gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc);
void main_channel_client_connect_seamless(MainChannelClient *mcc);
void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
int success,
int seamless);
void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
uint32_t src_version);
void main_channel_client_handle_migrate_end(MainChannelClient *mcc);
void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc);
void main_channel_client_migrate_dst_complete(MainChannelClient *mcc);
gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
gboolean success);
/*
* return TRUE if network test had been completed successfully.
* If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
*/
int main_channel_client_is_network_info_initialized(MainChannelClient *mcc);
int main_channel_client_is_low_bandwidth(MainChannelClient *mcc);
uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc);
uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc);
void main_channel_client_push_name(MainChannelClient *mcc, const char *name);
void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]);
uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc);
enum {
RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
RED_PIPE_ITEM_TYPE_MAIN_PING,

25
server/main-channel.cpp
View File

@ -34,7 +34,7 @@ RedClient *MainChannel::get_client_by_link_id(uint32_t connection_id)
FOREACH_CLIENT(this, rcc) {
MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
if (main_channel_client_get_connection_id(mcc) == connection_id) {
if (mcc->get_connection_id() == connection_id) {
return rcc->get_client();
}
}
@ -163,24 +163,19 @@ bool MainChannelClient::handle_message(uint16_t type, uint32_t size, void *messa
main_channel_push_channels(this);
break;
case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
main_channel_client_handle_migrate_connected(this,
TRUE /* success */,
FALSE /* seamless */);
this->handle_migrate_connected(TRUE, FALSE);
break;
case SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS:
main_channel_client_handle_migrate_connected(this,
TRUE /* success */,
TRUE /* seamless */);
this->handle_migrate_connected(TRUE, TRUE);
break;
case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
main_channel_client_handle_migrate_connected(this, FALSE, FALSE);
this->handle_migrate_connected(FALSE, FALSE);
break;
case SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS:
main_channel_client_handle_migrate_dst_do_seamless(this,
((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
this->handle_migrate_dst_do_seamless(((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
break;
case SPICE_MSGC_MAIN_MIGRATE_END:
main_channel_client_handle_migrate_end(this);
this->handle_migrate_end();
break;
case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST:
reds_on_main_mouse_mode_request(reds, message, size);
@ -234,7 +229,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel)
FOREACH_CLIENT(main_channel, rcc) {
MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
if (main_channel_client_connect_semi_seamless(mcc))
if (mcc->connect_semi_seamless())
main_channel->num_clients_mig_wait++;
}
return main_channel->num_clients_mig_wait;
@ -248,7 +243,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel)
FOREACH_CLIENT(main_channel, rcc) {
MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
main_channel_client_connect_seamless(mcc);
mcc->connect_seamless();
main_channel->num_clients_mig_wait++;
}
return main_channel->num_clients_mig_wait;
@ -287,7 +282,7 @@ void MainChannel::migrate_cancel_wait()
FOREACH_CLIENT(this, rcc) {
MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
main_channel_client_migrate_cancel_wait(mcc);
mcc->migrate_cancel_wait();
}
num_clients_mig_wait = 0;
}
@ -304,7 +299,7 @@ int MainChannel::migrate_src_complete(int success)
FOREACH_CLIENT(this, rcc) {
MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
if (main_channel_client_migrate_src_complete(mcc, success))
if (mcc->migrate_src_complete(success))
semi_seamless_count++;
}
return semi_seamless_count;

38
server/reds.cpp
View File

@ -944,8 +944,7 @@ static void vdi_port_send_msg_to_client(RedCharDevice *self,
RedVDIReadBuf *agent_data_buf = (RedVDIReadBuf *)msg;
red_pipe_item_ref(msg);
main_channel_client_push_agent_data(client->get_main(),
agent_data_buf->data,
client->get_main()->push_agent_data(agent_data_buf->data,
agent_data_buf->len,
vdi_port_read_buf_release,
agent_data_buf);
@ -955,8 +954,7 @@ static void vdi_port_send_tokens_to_client(RedCharDevice *self,
RedClient *client,
uint32_t tokens)
{
main_channel_client_push_agent_tokens(client->get_main(),
tokens);
client->get_main()->push_agent_tokens(tokens);
}
static void vdi_port_on_free_self_token(RedCharDevice *self)
@ -1313,11 +1311,8 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
switch (vdi_port_read_buf_process(agent_dev, read_buf)) {
case AGENT_MSG_FILTER_OK:
reds_adjust_agent_capabilities(reds, (VDAgentMessage *)read_buf->data);
main_channel_client_push_agent_data(mcc,
read_buf->data,
read_buf->len,
vdi_port_read_buf_release,
read_buf);
mcc->push_agent_data(read_buf->data, read_buf->len,
vdi_port_read_buf_release, read_buf);
break;
case AGENT_MSG_FILTER_PROTO_ERROR:
reds_agent_remove(reds);
@ -1891,14 +1886,14 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
}
if (!mig_target) {
main_channel_client_push_init(mcc, g_list_length(reds->qxl_instances),
reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
mcc->push_init(g_list_length(reds->qxl_instances), reds->mouse_mode,
reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
if (reds->config->spice_name)
main_channel_client_push_name(mcc, reds->config->spice_name);
mcc->push_name(reds->config->spice_name);
if (reds->config->spice_uuid_is_set)
main_channel_client_push_uuid(mcc, reds->config->spice_uuid);
mcc->push_uuid(reds->config->spice_uuid);
} else {
reds_mig_target_client_add(reds, client);
}
@ -2012,7 +2007,7 @@ void reds_on_client_seamless_migrate_complete(RedsState *reds, RedClient *client
spice_debug("client no longer exists");
return;
}
main_channel_client_migrate_dst_complete(client->get_main());
client->get_main()->migrate_dst_complete();
}
void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *client)
@ -2023,13 +2018,12 @@ void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *c
mcc = client->get_main();
// TODO: not doing net test. consider doing it on client_migrate_info
main_channel_client_push_init(mcc, g_list_length(reds->qxl_instances),
reds->mouse_mode,
reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
mcc->push_init(g_list_length(reds->qxl_instances), reds->mouse_mode,
reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
reds_link_mig_target_channels(reds, client);
main_channel_client_migrate_dst_complete(mcc);
mcc->migrate_dst_complete();
}
static void reds_handle_other_links(RedsState *reds, RedLinkInfo *link)

2
server/sound.cpp
View File

@ -758,7 +758,7 @@ bool SndChannelClient::config_socket()
}
#endif
red_stream_set_no_delay(stream, !main_channel_client_is_low_bandwidth(mcc));
red_stream_set_no_delay(stream, !mcc->is_low_bandwidth());
return true;
}

6
server/video-stream.cpp
View File

@ -641,8 +641,8 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient *dcc, VideoStream *str
uint64_t net_test_bit_rate;
mcc = dcc->get_client()->get_main();
net_test_bit_rate = main_channel_client_is_network_info_initialized(mcc) ?
main_channel_client_get_bitrate_per_sec(mcc) :
net_test_bit_rate = mcc->is_network_info_initialized() ?
mcc->get_bitrate_per_sec() :
0;
bit_rate = MAX(dcc_get_max_stream_bit_rate(dcc), net_test_bit_rate);
if (bit_rate == 0) {
@ -680,7 +680,7 @@ static uint32_t get_roundtrip_ms(void *opaque)
* calculated (e.g., after migration). In such case,
* main_channel_client_get_roundtrip_ms returns 0.
*/
roundtrip = main_channel_client_get_roundtrip_ms(mcc);
roundtrip = mcc->get_roundtrip_ms();
}
return roundtrip;