On Fri, 2016-04-01 at 16:11 -0500, Jonathon Jongsma wrote:
> While we're cleaning things up here, Do we want to keep the VDIPortState name?
> The "State" part of it no longer makes as much sense since it doesn't
> 'inherit'
> from SpiceCharDeviceState anymore. Possibilities: RedCharDeviceVDIPort,
> RedVDIPort?
>
I didn't look far enough ahead. The next patch does use RedCharDeviceVDIPort as
the typename, so I'll ACK this patch.
Acked-by: Jonathon Jongsma <jjongsma@xxxxxxxxxx>
> The rest of the patch is basically mechanical, and looks fine.
>
> Reviewed-by: Jonathon Jongsma <jjongsma@xxxxxxxxxx>
>
>
> On Fri, 2016-04-01 at 15:51 -0500, Jonathon Jongsma wrote:
> > From: Christophe Fergeau <cfergeau@xxxxxxxxxx>
> >
> > This inherits from RedCharDevice.
> >
> > Signed-off-by: Christophe Fergeau <cfergeau@xxxxxxxxxx>
> > Signed-off-by: Frediano Ziglio <fziglio@xxxxxxxxxx>
> > ---
> > server/reds.c | 395 +++++++++++++++++++++++++++++--------------------------
> > --
> > -
> > 1 file changed, 200 insertions(+), 195 deletions(-)
> >
> > diff --git a/server/reds.c b/server/reds.c
> > index 7538d9b..23df51a 100644
> > --- a/server/reds.c
> > +++ b/server/reds.c
> > @@ -181,7 +181,7 @@ enum {
> > VDI_PORT_READ_STATE_READ_DATA,
> > };
> >
> > -struct VDIPortState {
> > +struct VDIPortStatePrivate {
> > RedCharDevice *base;
> > uint32_t plug_generation;
> > int client_agent_started;
> > @@ -206,6 +206,10 @@ struct VDIPortState {
> > before agent is attached */
> > };
> >
> > +struct VDIPortState {
> > + struct VDIPortStatePrivate priv[1];
> > +};
> > +
> > /* messages that are addressed to the agent and are created in the server
> > */
> > typedef struct __attribute__ ((__packed__)) VDInternalBuf {
> > VDIChunkHeader chunk_header;
> > @@ -450,16 +454,16 @@ static void reds_reset_vdp(RedsState *reds)
> > VDIPortState *state = reds->agent_state;
> > SpiceCharDeviceInterface *sif;
> >
> > - state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > - state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
> > - state->receive_len = sizeof(state->vdi_chunk_header);
> > - state->message_receive_len = 0;
> > - if (state->current_read_buf) {
> > - vdi_port_read_buf_unref(state->current_read_buf);
> > - state->current_read_buf = NULL;
> > + state->priv->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > + state->priv->receive_pos = (uint8_t *)&state->priv->vdi_chunk_header;
> > + state->priv->receive_len = sizeof(state->priv->vdi_chunk_header);
> > + state->priv->message_receive_len = 0;
> > + if (state->priv->current_read_buf) {
> > + vdi_port_read_buf_unref(state->priv->current_read_buf);
> > + state->priv->current_read_buf = NULL;
> > }
> > /* Reset read filter to start with clean state when the agent
> > reconnects
> > */
> > - agent_msg_filter_init(&state->read_filter, reds->agent_copypaste,
> > + agent_msg_filter_init(&state->priv->read_filter, reds->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds), TRUE);
> > /* Throw away pending chunks from the current (if any) and future
> > @@ -468,9 +472,9 @@ static void reds_reset_vdp(RedsState *reds)
> > * is disconnected. Currently, when an agent gets disconnected and
> > reconnected,
> > * messages that were directed to the previous instance of the agent
> > continue
> > * to be sent from the client. This TODO will require server, protocol,
> > and client changes */
> > - state->write_filter.result = AGENT_MSG_FILTER_DISCARD;
> > - state->write_filter.discard_all = TRUE;
> > - state->client_agent_started = FALSE;
> > + state->priv->write_filter.result = AGENT_MSG_FILTER_DISCARD;
> > + state->priv->write_filter.discard_all = TRUE;
> > + state->priv->client_agent_started = FALSE;
> >
> > /* resetting and not destroying the state as a workaround for a bad
> > * tokens management in the vdagent protocol:
> > @@ -485,10 +489,10 @@ static void reds_reset_vdp(RedsState *reds)
> > */
> > if (red_channel_test_remote_cap(&reds->main_channel->base,
> > SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS))
> > {
> > - red_char_device_destroy(state->base);
> > - state->base = NULL;
> > + red_char_device_destroy(state->priv->base);
> > + state->priv->base = NULL;
> > } else {
> > - red_char_device_reset(state->base);
> > + red_char_device_reset(state->priv->base);
> > }
> >
> > sif = spice_char_device_get_interface(reds->vdagent);
> > @@ -536,11 +540,11 @@ void reds_client_disconnect(RedsState *reds, RedClient
> > *client)
> > reds_mig_remove_wait_disconnect_client(reds, client);
> > }
> >
> > - if (reds->agent_state->base) {
> > + if (reds->agent_state->priv->base) {
> > /* note that vdagent might be NULL, if the vdagent was once
> > * up and than was removed */
> > - if (red_char_device_client_exists(reds->agent_state->base, client))
> > {
> > - red_char_device_client_remove(reds->agent_state->base, client);
> > + if (red_char_device_client_exists(reds->agent_state->priv->base,
> > client)) {
> > + red_char_device_client_remove(reds->agent_state->priv->base,
> > client);
> > }
> > }
> >
> > @@ -552,14 +556,14 @@ void reds_client_disconnect(RedsState *reds, RedClient
> > *client)
> > // if we are in the middle of one from another client)
> > if (reds->num_clients == 0) {
> > /* Let the agent know the client is disconnected */
> > - if (reds->agent_state->base) {
> > + if (reds->agent_state->priv->base) {
> > RedCharDeviceWriteBuffer *char_dev_buf;
> > VDInternalBuf *internal_buf;
> > uint32_t total_msg_size;
> >
> > total_msg_size = sizeof(VDIChunkHeader) +
> > sizeof(VDAgentMessage);
> > char_dev_buf =
> > red_char_device_write_buffer_get_server_no_token(
> > - reds->agent_state->base, total_msg_size);
> > + reds->agent_state->priv->base,
> > total_msg_size);
> > char_dev_buf->buf_used = total_msg_size;
> > internal_buf = (VDInternalBuf *)char_dev_buf->buf;
> > internal_buf->chunk_header.port = VDP_SERVER_PORT;
> > @@ -569,21 +573,21 @@ void reds_client_disconnect(RedsState *reds, RedClient
> > *client)
> > internal_buf->header.opaque = 0;
> > internal_buf->header.size = 0;
> >
> > - red_char_device_write_buffer_add(reds->agent_state->base,
> > + red_char_device_write_buffer_add(reds->agent_state->priv->base,
> > char_dev_buf);
> > }
> >
> > /* Reset write filter to start with clean state on client reconnect
> > */
> > - agent_msg_filter_init(&reds->agent_state->write_filter, reds
> > ->agent_copypaste,
> > + agent_msg_filter_init(&reds->agent_state->priv->write_filter, reds
> > ->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds), TRUE);
> >
> > /* Throw away pending chunks from the current (if any) and future
> > * messages read from the agent */
> > - reds->agent_state->read_filter.result = AGENT_MSG_FILTER_DISCARD;
> > - reds->agent_state->read_filter.discard_all = TRUE;
> > - free(reds->agent_state->mig_data);
> > - reds->agent_state->mig_data = NULL;
> > + reds->agent_state->priv->read_filter.result =
> > AGENT_MSG_FILTER_DISCARD;
> > + reds->agent_state->priv->read_filter.discard_all = TRUE;
> > + free(reds->agent_state->priv->mig_data);
> > + reds->agent_state->priv->mig_data = NULL;
> >
> > reds_mig_cleanup(reds);
> > }
> > @@ -693,9 +697,9 @@ static gboolean vdi_port_read_buf_process(VDIPortState
> > *state, VDIReadBuf *buf,
> >
> > *error = FALSE;
> >
> > - switch (state->vdi_chunk_header.port) {
> > + switch (state->priv->vdi_chunk_header.port) {
> > case VDP_CLIENT_PORT: {
> > - res = agent_msg_filter_process_data(&state->read_filter,
> > + res = agent_msg_filter_process_data(&state->priv->read_filter,
> > buf->data, buf->len);
> > switch (res) {
> > case AGENT_MSG_FILTER_OK:
> > @@ -721,7 +725,7 @@ static VDIReadBuf
> > *vdi_port_state_get_read_buf(VDIPortState *state)
> > RingItem *item;
> > VDIReadBuf *buf;
> >
> > - if (!(item = ring_get_head(&state->read_bufs))) {
> > + if (!(item = ring_get_head(&state->priv->read_bufs))) {
> > return NULL;
> > }
> >
> > @@ -743,14 +747,14 @@ static VDIReadBuf* vdi_port_read_buf_ref(VDIReadBuf
> > *buf)
> > static void vdi_port_read_buf_unref(VDIReadBuf *buf)
> > {
> > if (!--buf->refs) {
> > - ring_add(&buf->state->read_bufs, &buf->link);
> > + ring_add(&buf->state->priv->read_bufs, &buf->link);
> >
> > /* read_one_msg_from_vdi_port may have never completed because the
> > read_bufs
> > ring was empty. So we call it again so it can complete its work if
> > necessary. Note that since we can be called from
> > red_char_device_wakeup
> > this can cause recursion, but we have protection for that */
> > - if (buf->state->base) {
> > - red_char_device_wakeup(buf->state->base);
> > + if (buf->state->priv->base) {
> > + red_char_device_wakeup(buf->state->priv->base);
> > }
> > }
> > }
> > @@ -772,48 +776,48 @@ static RedCharDeviceMsgToClient
> > *vdi_port_read_one_msg_from_device(SpiceCharDevi
> > spice_assert(reds->vdagent == sin);
> > sif = spice_char_device_get_interface(reds->vdagent);
> > while (reds->vdagent) {
> > - switch (state->read_state) {
> > + switch (state->priv->read_state) {
> > case VDI_PORT_READ_STATE_READ_HEADER:
> > - n = sif->read(reds->vdagent, state->receive_pos, state
> > ->receive_len);
> > + n = sif->read(reds->vdagent, state->priv->receive_pos, state
> > ->priv->receive_len);
> > if (!n) {
> > return NULL;
> > }
> > - if ((state->receive_len -= n)) {
> > - state->receive_pos += n;
> > + if ((state->priv->receive_len -= n)) {
> > + state->priv->receive_pos += n;
> > return NULL;
> > }
> > - state->message_receive_len = state->vdi_chunk_header.size;
> > - state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > + state->priv->message_receive_len = state->priv
> > ->vdi_chunk_header.size;
> > + state->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > case VDI_PORT_READ_STATE_GET_BUFF: {
> > - if (!(state->current_read_buf =
> > vdi_port_state_get_read_buf(reds
> > ->agent_state))) {
> > + if (!(state->priv->current_read_buf =
> > vdi_port_state_get_read_buf(reds->agent_state))) {
> > return NULL;
> > }
> > - state->receive_pos = state->current_read_buf->data;
> > - state->receive_len = MIN(state->message_receive_len,
> > - sizeof(state->current_read_buf->data));
> > - state->current_read_buf->len = state->receive_len;
> > - state->message_receive_len -= state->receive_len;
> > - state->read_state = VDI_PORT_READ_STATE_READ_DATA;
> > + state->priv->receive_pos = state->priv->current_read_buf->data;
> > + state->priv->receive_len = MIN(state->priv
> > ->message_receive_len,
> > + sizeof(state->priv
> > ->current_read_buf->data));
> > + state->priv->current_read_buf->len = state->priv->receive_len;
> > + state->priv->message_receive_len -= state->priv->receive_len;
> > + state->priv->read_state = VDI_PORT_READ_STATE_READ_DATA;
> > }
> > case VDI_PORT_READ_STATE_READ_DATA: {
> > gboolean error = FALSE;
> > - n = sif->read(reds->vdagent, state->receive_pos, state
> > ->receive_len);
> > + n = sif->read(reds->vdagent, state->priv->receive_pos, state
> > ->priv->receive_len);
> > if (!n) {
> > return NULL;
> > }
> > - if ((state->receive_len -= n)) {
> > - state->receive_pos += n;
> > + if ((state->priv->receive_len -= n)) {
> > + state->priv->receive_pos += n;
> > break;
> > }
> > - dispatch_buf = state->current_read_buf;
> > - state->current_read_buf = NULL;
> > - state->receive_pos = NULL;
> > - if (state->message_receive_len == 0) {
> > - state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > - state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
> > - state->receive_len = sizeof(state->vdi_chunk_header);
> > + dispatch_buf = state->priv->current_read_buf;
> > + state->priv->current_read_buf = NULL;
> > + state->priv->receive_pos = NULL;
> > + if (state->priv->message_receive_len == 0) {
> > + state->priv->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > + state->priv->receive_pos = (uint8_t *)&state->priv
> > ->vdi_chunk_header;
> > + state->priv->receive_len = sizeof(state->priv
> > ->vdi_chunk_header);
> > } else {
> > - state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > + state->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > }
> > if (vdi_port_read_buf_process(reds->agent_state, dispatch_buf,
> > &error)) {
> > return dispatch_buf;
> > @@ -890,13 +894,13 @@ void reds_handle_agent_mouse_event(RedsState *reds,
> > const VDAgentMouseState *mou
> > VDInternalBuf *internal_buf;
> > uint32_t total_msg_size;
> >
> > - if (!reds->inputs_channel || !reds->agent_state->base) {
> > + if (!reds->inputs_channel || !reds->agent_state->priv->base) {
> > return;
> > }
> >
> > total_msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) +
> > sizeof(VDAgentMouseState);
> > - char_dev_buf = red_char_device_write_buffer_get(reds->agent_state
> > ->base,
> > + char_dev_buf = red_char_device_write_buffer_get(reds->agent_state->priv
> > ->base,
> > NULL,
> > total_msg_size);
> >
> > @@ -917,7 +921,7 @@ void reds_handle_agent_mouse_event(RedsState *reds,
> > const
> > VDAgentMouseState *mou
> > internal_buf->u.mouse_state = *mouse_state;
> >
> > char_dev_buf->buf_used = total_msg_size;
> > - red_char_device_write_buffer_add(reds->agent_state->base,
> > char_dev_buf);
> > + red_char_device_write_buffer_add(reds->agent_state->priv->base,
> > char_dev_buf);
> > }
> >
> > int reds_get_n_channels(RedsState *reds)
> > @@ -973,7 +977,7 @@ void reds_fill_channels(RedsState *reds,
> > SpiceMsgChannels
> > *channels_info)
> >
> > void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc,
> > uint32_t num_tokens)
> > {
> > - RedCharDevice *dev_state = reds->agent_state->base;
> > + RedCharDevice *dev_state = reds->agent_state->priv->base;
> > RedChannelClient *rcc;
> >
> > if (!reds->vdagent) {
> > @@ -981,7 +985,7 @@ void reds_on_main_agent_start(RedsState *reds,
> > MainChannelClient *mcc, uint32_t
> > }
> > spice_assert(reds->vdagent->st && reds->vdagent->st == dev_state);
> > rcc = main_channel_client_get_base(mcc);
> > - reds->agent_state->client_agent_started = TRUE;
> > + reds->agent_state->priv->client_agent_started = TRUE;
> > /*
> > * Note that in older releases, send_tokens were set to ~0 on both
> > client
> > * and server. The server ignored the client given tokens.
> > @@ -1011,10 +1015,10 @@ void reds_on_main_agent_start(RedsState *reds,
> > MainChannelClient *mcc, uint32_t
> > num_tokens);
> > }
> >
> > - agent_msg_filter_config(&reds->agent_state->write_filter, reds
> > ->agent_copypaste,
> > + agent_msg_filter_config(&reds->agent_state->priv->write_filter, reds
> > ->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds));
> > - reds->agent_state->write_filter.discard_all = FALSE;
> > + reds->agent_state->priv->write_filter.discard_all = FALSE;
> > }
> >
> > void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc,
> > uint32_t num_tokens)
> > @@ -1033,7 +1037,7 @@ uint8_t *reds_get_agent_data_buffer(RedsState *reds,
> > MainChannelClient *mcc, siz
> > VDIPortState *dev_state = reds->agent_state;
> > RedClient *client;
> >
> > - if (!dev_state->client_agent_started) {
> > + if (!dev_state->priv->client_agent_started) {
> > /*
> > * agent got disconnected, and possibly got reconnected, but we
> > still
> > can receive
> > * msgs that are addressed to the agent's old instance, in case
> > they
> > were
> > @@ -1044,31 +1048,31 @@ uint8_t *reds_get_agent_data_buffer(RedsState *reds,
> > MainChannelClient *mcc, siz
> > return spice_malloc(size);
> > }
> >
> > - spice_assert(dev_state->recv_from_client_buf == NULL);
> > + spice_assert(dev_state->priv->recv_from_client_buf == NULL);
> > client = main_channel_client_get_base(mcc)->client;
> > - dev_state->recv_from_client_buf =
> > red_char_device_write_buffer_get(dev_state->base,
> > -
> > client,
> > - size
> > +
> > sizeof(VDIChunkHeader));
> > - dev_state->recv_from_client_buf_pushed = FALSE;
> > - return dev_state->recv_from_client_buf->buf + sizeof(VDIChunkHeader);
> > + dev_state->priv->recv_from_client_buf =
> > red_char_device_write_buffer_get(dev_state->priv->base,
> > +
> > client,
> > +
> > size + sizeof(VDIChunkHeader));
> > + dev_state->priv->recv_from_client_buf_pushed = FALSE;
> > + return dev_state->priv->recv_from_client_buf->buf +
> > sizeof(VDIChunkHeader);
> > }
> >
> > void reds_release_agent_data_buffer(RedsState *reds, uint8_t *buf)
> > {
> > VDIPortState *dev_state = reds->agent_state;
> >
> > - if (!dev_state->recv_from_client_buf) {
> > + if (!dev_state->priv->recv_from_client_buf) {
> > free(buf);
> > return;
> > }
> >
> > - spice_assert(buf == dev_state->recv_from_client_buf->buf +
> > sizeof(VDIChunkHeader));
> > - if (!dev_state->recv_from_client_buf_pushed) {
> > - red_char_device_write_buffer_release(reds->agent_state->base,
> > - dev_state
> > ->recv_from_client_buf);
> > + spice_assert(buf == dev_state->priv->recv_from_client_buf->buf +
> > sizeof(VDIChunkHeader));
> > + if (!dev_state->priv->recv_from_client_buf_pushed) {
> > + red_char_device_write_buffer_release(reds->agent_state->priv->base,
> > + dev_state->priv
> > ->recv_from_client_buf);
> > }
> > - dev_state->recv_from_client_buf = NULL;
> > - dev_state->recv_from_client_buf_pushed = FALSE;
> > + dev_state->priv->recv_from_client_buf = NULL;
> > + dev_state->priv->recv_from_client_buf_pushed = FALSE;
> > }
> >
> > static void reds_client_monitors_config_cleanup(RedsState *reds)
> > @@ -1112,7 +1116,7 @@ void reds_on_main_agent_data(RedsState *reds,
> > MainChannelClient *mcc, void *mess
> > VDIChunkHeader *header;
> > int res;
> >
> > - res = agent_msg_filter_process_data(&reds->agent_state->write_filter,
> > + res = agent_msg_filter_process_data(&reds->agent_state->priv
> > ->write_filter,
> > message, size);
> > switch (res) {
> > case AGENT_MSG_FILTER_OK:
> > @@ -1127,16 +1131,16 @@ void reds_on_main_agent_data(RedsState *reds,
> > MainChannelClient *mcc, void *mess
> > return;
> > }
> >
> > - spice_assert(reds->agent_state->recv_from_client_buf);
> > - spice_assert(message == reds->agent_state->recv_from_client_buf->buf +
> > sizeof(VDIChunkHeader));
> > + spice_assert(reds->agent_state->priv->recv_from_client_buf);
> > + spice_assert(message == reds->agent_state->priv->recv_from_client_buf
> > ->buf + sizeof(VDIChunkHeader));
> > // TODO - start tracking agent data per channel
> > - header = (VDIChunkHeader *)dev_state->recv_from_client_buf->buf;
> > + header = (VDIChunkHeader *)dev_state->priv->recv_from_client_buf->buf;
> > header->port = VDP_CLIENT_PORT;
> > header->size = size;
> > - dev_state->recv_from_client_buf->buf_used = sizeof(VDIChunkHeader) +
> > size;
> > + dev_state->priv->recv_from_client_buf->buf_used =
> > sizeof(VDIChunkHeader)
> > + size;
> >
> > - dev_state->recv_from_client_buf_pushed = TRUE;
> > - red_char_device_write_buffer_add(reds->agent_state->base, dev_state
> > ->recv_from_client_buf);
> > + dev_state->priv->recv_from_client_buf_pushed = TRUE;
> > + red_char_device_write_buffer_add(reds->agent_state->priv->base,
> > dev_state
> > ->priv->recv_from_client_buf);
> > }
> >
> > void reds_on_main_migrate_connected(RedsState *reds, int seamless)
> > @@ -1176,20 +1180,20 @@ void reds_on_main_channel_migrate(RedsState *reds,
> > MainChannelClient *mcc)
> >
> > spice_assert(reds->num_clients == 1);
> >
> > - if (agent_state->read_state != VDI_PORT_READ_STATE_READ_DATA) {
> > + if (agent_state->priv->read_state != VDI_PORT_READ_STATE_READ_DATA) {
> > return;
> > }
> > - spice_assert(agent_state->current_read_buf->data &&
> > - agent_state->receive_pos > agent_state->current_read_buf
> > ->data);
> > - read_data_len = agent_state->receive_pos - agent_state
> > ->current_read_buf
> > ->data;
> > + spice_assert(agent_state->priv->current_read_buf->data &&
> > + agent_state->priv->receive_pos > agent_state->priv
> > ->current_read_buf->data);
> > + read_data_len = agent_state->priv->receive_pos - agent_state->priv
> > ->current_read_buf->data;
> >
> > - if (agent_state->read_filter.msg_data_to_read ||
> > + if (agent_state->priv->read_filter.msg_data_to_read ||
> > read_data_len > sizeof(VDAgentMessage)) { /* msg header has been
> > read
> > */
> > - VDIReadBuf *read_buf = agent_state->current_read_buf;
> > + VDIReadBuf *read_buf = agent_state->priv->current_read_buf;
> > gboolean error = FALSE;
> >
> > spice_debug("push partial read %u (msg first chunk? %d)",
> > read_data_len,
> > - !agent_state->read_filter.msg_data_to_read);
> > + !agent_state->priv->read_filter.msg_data_to_read);
> >
> > read_buf->len = read_data_len;
> > if (vdi_port_read_buf_process(reds->agent_state, read_buf, &error))
> > {
> > @@ -1205,11 +1209,11 @@ void reds_on_main_channel_migrate(RedsState *reds,
> > MainChannelClient *mcc)
> > vdi_port_read_buf_unref(read_buf);
> > }
> >
> > - spice_assert(agent_state->receive_len);
> > - agent_state->message_receive_len += agent_state->receive_len;
> > - agent_state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > - agent_state->current_read_buf = NULL;
> > - agent_state->receive_pos = NULL;
> > + spice_assert(agent_state->priv->receive_len);
> > + agent_state->priv->message_receive_len += agent_state->priv
> > ->receive_len;
> > + agent_state->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > + agent_state->priv->current_read_buf = NULL;
> > + agent_state->priv->receive_pos = NULL;
> > }
> > }
> >
> > @@ -1226,11 +1230,12 @@ void reds_marshall_migrate_data(RedsState *reds,
> > SpiceMarshaller *m)
> > if (!reds->vdagent) {
> > uint8_t *null_agent_mig_data;
> >
> > - spice_assert(!agent_state->base); /* MSG_AGENT_CONNECTED_TOKENS is
> > supported by the client
> > - (see
> > spice_server_migrate_connect), so RedCharDevice
> > - is destroyed when the agent is
> > disconnected and
> > - there is no need to track the
> > client tokens
> > - (see reds_reset_vdp) */
> > + /* MSG_AGENT_CONNECTED_TOKENS is supported by the client
> > + (see spice_server_migrate_connect), so agent_attached
> > + is set to FALSE when the agent is disconnected and
> > + there is no need to track the client tokens
> > + (see reds_reset_vdp) */
> > + spice_assert(!agent_state->priv->base);
> > red_char_device_migrate_data_marshall_empty(m);
> > null_agent_mig_data = spice_marshaller_reserve_space(m,
> >
> > sizeof(SpiceMigrateDataMain) -
> > @@ -1241,33 +1246,33 @@ void reds_marshall_migrate_data(RedsState *reds,
> > SpiceMarshaller *m)
> > return;
> > }
> >
> > - red_char_device_migrate_data_marshall(reds->agent_state->base, m);
> > - spice_marshaller_add_uint8(m, reds->agent_state->client_agent_started);
> > + red_char_device_migrate_data_marshall(reds->agent_state->priv->base,
> > m);
> > + spice_marshaller_add_uint8(m, reds->agent_state->priv
> > ->client_agent_started);
> >
> > - mig_data.agent2client.chunk_header = agent_state->vdi_chunk_header;
> > + mig_data.agent2client.chunk_header = agent_state->priv
> > ->vdi_chunk_header;
> >
> > /* agent to client partial msg */
> > - if (agent_state->read_state == VDI_PORT_READ_STATE_READ_HEADER) {
> > - mig_data.agent2client.chunk_header_size = agent_state->receive_pos
> > -
> > - (uint8_t *)&agent_state->vdi_chunk_header;
> > + if (agent_state->priv->read_state == VDI_PORT_READ_STATE_READ_HEADER) {
> > + mig_data.agent2client.chunk_header_size = agent_state->priv
> > ->receive_pos -
> > + (uint8_t *)&agent_state->priv->vdi_chunk_header;
> >
> > mig_data.agent2client.msg_header_done = FALSE;
> > mig_data.agent2client.msg_header_partial_len = 0;
> > - spice_assert(!agent_state->read_filter.msg_data_to_read);
> > + spice_assert(!agent_state->priv->read_filter.msg_data_to_read);
> > } else {
> > mig_data.agent2client.chunk_header_size = sizeof(VDIChunkHeader);
> > - mig_data.agent2client.chunk_header.size = agent_state
> > ->message_receive_len;
> > - if (agent_state->read_state == VDI_PORT_READ_STATE_READ_DATA) {
> > + mig_data.agent2client.chunk_header.size = agent_state->priv
> > ->message_receive_len;
> > + if (agent_state->priv->read_state == VDI_PORT_READ_STATE_READ_DATA)
> > {
> > /* in the middle of reading the message header (see
> > reds_on_main_channel_migrate) */
> > mig_data.agent2client.msg_header_done = FALSE;
> > mig_data.agent2client.msg_header_partial_len =
> > - agent_state->receive_pos - agent_state->current_read_buf
> > ->data;
> > + agent_state->priv->receive_pos - agent_state->priv
> > ->current_read_buf->data;
> > spice_assert(mig_data.agent2client.msg_header_partial_len <
> > sizeof(VDAgentMessage));
> > - spice_assert(!agent_state->read_filter.msg_data_to_read);
> > + spice_assert(!agent_state->priv->read_filter.msg_data_to_read);
> > } else {
> > mig_data.agent2client.msg_header_done = TRUE;
> > - mig_data.agent2client.msg_remaining = agent_state
> > ->read_filter.msg_data_to_read;
> > - mig_data.agent2client.msg_filter_result = agent_state
> > ->read_filter.result;
> > + mig_data.agent2client.msg_remaining = agent_state->priv
> > ->read_filter.msg_data_to_read;
> > + mig_data.agent2client.msg_filter_result = agent_state->priv
> > ->read_filter.result;
> > }
> > }
> > spice_marshaller_add_uint32(m,
> > mig_data.agent2client.chunk_header_size);
> > @@ -1277,23 +1282,23 @@ void reds_marshall_migrate_data(RedsState *reds,
> > SpiceMarshaller *m)
> > spice_marshaller_add_uint8(m, mig_data.agent2client.msg_header_done);
> > spice_marshaller_add_uint32(m,
> > mig_data.agent2client.msg_header_partial_len);
> > m2 = spice_marshaller_get_ptr_submarshaller(m, 0);
> > - spice_marshaller_add(m2, agent_state->current_read_buf->data,
> > + spice_marshaller_add(m2, agent_state->priv->current_read_buf->data,
> > mig_data.agent2client.msg_header_partial_len);
> > spice_marshaller_add_uint32(m, mig_data.agent2client.msg_remaining);
> > spice_marshaller_add_uint8(m, mig_data.agent2client.msg_filter_result);
> >
> > - mig_data.client2agent.msg_remaining = agent_state
> > ->write_filter.msg_data_to_read;
> > - mig_data.client2agent.msg_filter_result = agent_state
> > ->write_filter.result;
> > + mig_data.client2agent.msg_remaining = agent_state->priv
> > ->write_filter.msg_data_to_read;
> > + mig_data.client2agent.msg_filter_result = agent_state->priv
> > ->write_filter.result;
> > spice_marshaller_add_uint32(m, mig_data.client2agent.msg_remaining);
> > spice_marshaller_add_uint8(m, mig_data.client2agent.msg_filter_result);
> > spice_debug("from agent filter: discard all %d, wait_msg %u,
> > msg_filter_result %d",
> > - agent_state->read_filter.discard_all,
> > - agent_state->read_filter.msg_data_to_read,
> > - agent_state->read_filter.result);
> > + agent_state->priv->read_filter.discard_all,
> > + agent_state->priv->read_filter.msg_data_to_read,
> > + agent_state->priv->read_filter.result);
> > spice_debug("to agent filter: discard all %d, wait_msg %u,
> > msg_filter_result %d",
> > - agent_state->write_filter.discard_all,
> > - agent_state->write_filter.msg_data_to_read,
> > - agent_state->write_filter.result);
> > + agent_state->priv->write_filter.discard_all,
> > + agent_state->priv->write_filter.msg_data_to_read,
> > + agent_state->priv->write_filter.result);
> > }
> >
> > static int reds_agent_state_restore(RedsState *reds, SpiceMigrateDataMain
> > *mig_data)
> > @@ -1301,16 +1306,16 @@ static int reds_agent_state_restore(RedsState *reds,
> > SpiceMigrateDataMain *mig_d
> > VDIPortState *agent_state = reds->agent_state;
> > uint32_t chunk_header_remaining;
> >
> > - agent_state->vdi_chunk_header = mig_data->agent2client.chunk_header;
> > + agent_state->priv->vdi_chunk_header = mig_data
> > ->agent2client.chunk_header;
> > spice_assert(mig_data->agent2client.chunk_header_size <=
> > sizeof(VDIChunkHeader));
> > chunk_header_remaining = sizeof(VDIChunkHeader) - mig_data
> > ->agent2client.chunk_header_size;
> > if (chunk_header_remaining) {
> > - agent_state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > - agent_state->receive_pos = (uint8_t *)&agent_state
> > ->vdi_chunk_header
> > +
> > + agent_state->priv->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > + agent_state->priv->receive_pos = (uint8_t *)&agent_state->priv
> > ->vdi_chunk_header +
> > mig_data->agent2client.chunk_header_size;
> > - agent_state->receive_len = chunk_header_remaining;
> > + agent_state->priv->receive_len = chunk_header_remaining;
> > } else {
> > - agent_state->message_receive_len = agent_state
> > ->vdi_chunk_header.size;
> > + agent_state->priv->message_receive_len = agent_state->priv
> > ->vdi_chunk_header.size;
> > }
> >
> > if (!mig_data->agent2client.msg_header_done) {
> > @@ -1319,49 +1324,49 @@ static int reds_agent_state_restore(RedsState *reds,
> > SpiceMigrateDataMain *mig_d
> > if (!chunk_header_remaining) {
> > uint32_t cur_buf_size;
> >
> > - agent_state->read_state = VDI_PORT_READ_STATE_READ_DATA;
> > - agent_state->current_read_buf =
> > vdi_port_state_get_read_buf(reds
> > ->agent_state);
> > - spice_assert(agent_state->current_read_buf);
> > + agent_state->priv->read_state = VDI_PORT_READ_STATE_READ_DATA;
> > + agent_state->priv->current_read_buf =
> > vdi_port_state_get_read_buf(reds->agent_state);
> > + spice_assert(agent_state->priv->current_read_buf);
> > partial_msg_header = (uint8_t *)mig_data + mig_data
> > ->agent2client.msg_header_ptr -
> > sizeof(SpiceMiniDataHeader);
> > - memcpy(agent_state->current_read_buf->data,
> > + memcpy(agent_state->priv->current_read_buf->data,
> > partial_msg_header,
> > mig_data->agent2client.msg_header_partial_len);
> > - agent_state->receive_pos = agent_state->current_read_buf->data
> > +
> > + agent_state->priv->receive_pos = agent_state->priv
> > ->current_read_buf->data +
> > mig_data
> > ->agent2client.msg_header_partial_len;
> > - cur_buf_size = sizeof(agent_state->current_read_buf->data) -
> > + cur_buf_size = sizeof(agent_state->priv->current_read_buf
> > ->data)
> > -
> > mig_data->agent2client.msg_header_partial_len;
> > - agent_state->receive_len = MIN(agent_state
> > ->message_receive_len,
> > cur_buf_size);
> > - agent_state->current_read_buf->len = agent_state->receive_len +
> > + agent_state->priv->receive_len = MIN(agent_state->priv
> > ->message_receive_len, cur_buf_size);
> > + agent_state->priv->current_read_buf->len = agent_state->priv
> > ->receive_len +
> > mig_data
> > ->agent2client.msg_header_partial_len;
> > - agent_state->message_receive_len -= agent_state->receive_len;
> > + agent_state->priv->message_receive_len -= agent_state->priv
> > ->receive_len;
> > } else {
> > spice_assert(mig_data->agent2client.msg_header_partial_len ==
> > 0);
> > }
> > } else {
> > - agent_state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > - agent_state->current_read_buf = NULL;
> > - agent_state->receive_pos = NULL;
> > - agent_state->read_filter.msg_data_to_read = mig_data
> > ->agent2client.msg_remaining;
> > - agent_state->read_filter.result = mig_data
> > ->agent2client.msg_filter_result;
> > + agent_state->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > + agent_state->priv->current_read_buf = NULL;
> > + agent_state->priv->receive_pos = NULL;
> > + agent_state->priv->read_filter.msg_data_to_read = mig_data
> > ->agent2client.msg_remaining;
> > + agent_state->priv->read_filter.result = mig_data
> > ->agent2client.msg_filter_result;
> > }
> >
> > - agent_state->read_filter.discard_all = FALSE;
> > - agent_state->write_filter.discard_all = !mig_data
> > ->client_agent_started;
> > - agent_state->client_agent_started = mig_data->client_agent_started;
> > + agent_state->priv->read_filter.discard_all = FALSE;
> > + agent_state->priv->write_filter.discard_all = !mig_data
> > ->client_agent_started;
> > + agent_state->priv->client_agent_started = mig_data
> > ->client_agent_started;
> >
> > - agent_state->write_filter.msg_data_to_read = mig_data
> > ->client2agent.msg_remaining;
> > - agent_state->write_filter.result = mig_data
> > ->client2agent.msg_filter_result;
> > + agent_state->priv->write_filter.msg_data_to_read = mig_data
> > ->client2agent.msg_remaining;
> > + agent_state->priv->write_filter.result = mig_data
> > ->client2agent.msg_filter_result;
> >
> > spice_debug("to agent filter: discard all %d, wait_msg %u,
> > msg_filter_result %d",
> > - agent_state->write_filter.discard_all,
> > - agent_state->write_filter.msg_data_to_read,
> > - agent_state->write_filter.result);
> > + agent_state->priv->write_filter.discard_all,
> > + agent_state->priv->write_filter.msg_data_to_read,
> > + agent_state->priv->write_filter.result);
> > spice_debug("from agent filter: discard all %d, wait_msg %u,
> > msg_filter_result %d",
> > - agent_state->read_filter.discard_all,
> > - agent_state->read_filter.msg_data_to_read,
> > - agent_state->read_filter.result);
> > - return red_char_device_restore(agent_state->base, &mig_data
> > ->agent_base);
> > + agent_state->priv->read_filter.discard_all,
> > + agent_state->priv->read_filter.msg_data_to_read,
> > + agent_state->priv->read_filter.result);
> > + return red_char_device_restore(agent_state->priv->base, &mig_data
> > ->agent_base);
> > }
> >
> > /*
> > @@ -1384,14 +1389,14 @@ int reds_handle_migrate_data(RedsState *reds,
> > MainChannelClient *mcc,
> > reds_send_mm_time(reds);
> > }
> > if (mig_data->agent_base.connected) {
> > - if (agent_state->base) { // agent was attached before migration
> > data
> > has arrived
> > + if (agent_state->priv->base) { // agent was attached before
> > migration
> > data has arrived
> > if (!reds->vdagent) {
> > - spice_assert(agent_state->plug_generation > 0);
> > + spice_assert(agent_state->priv->plug_generation > 0);
> > main_channel_push_agent_disconnected(reds->main_channel);
> > spice_debug("agent is no longer connected");
> > } else {
> > - if (agent_state->plug_generation > 1) {
> > - /* red_char_device_reset takes care of not making the
> > device wait for migration data */
> > + if (agent_state->priv->plug_generation > 1) {
> > + /* red_char_device_state_reset takes care of not making
> > the device wait for migration data */
> > spice_debug("agent has been detached and reattached
> > before receiving migration data");
> > main_channel_push_agent_disconnected(reds
> > ->main_channel);
> > main_channel_push_agent_connected(reds->main_channel);
> > @@ -1403,14 +1408,14 @@ int reds_handle_migrate_data(RedsState *reds,
> > MainChannelClient *mcc,
> > } else {
> > /* restore agent starte when the agent gets attached */
> > spice_debug("saving mig_data");
> > - spice_assert(agent_state->plug_generation == 0);
> > - agent_state->mig_data = spice_memdup(mig_data, size);
> > + spice_assert(agent_state->priv->plug_generation == 0);
> > + agent_state->priv->mig_data = spice_memdup(mig_data, size);
> > }
> > } else {
> > spice_debug("agent was not attached on the source host");
> > if (reds->vdagent) {
> > /* red_char_device_client_remove disables waiting for migration
> > data */
> > - red_char_device_client_remove(agent_state->base,
> > + red_char_device_client_remove(agent_state->priv->base,
> > main_channel_client_get_base(mcc)
> > ->client);
> > main_channel_push_agent_connected(reds->main_channel);
> > }
> > @@ -1745,12 +1750,12 @@ static void reds_handle_main_link(RedsState *reds,
> > RedLinkInfo *link)
> > if (mig_target) {
> > spice_warning("unexpected: vdagent attached to destination
> > during
> > migration");
> > }
> > - agent_msg_filter_config(&reds->agent_state->read_filter,
> > + agent_msg_filter_config(&reds->agent_state->priv->read_filter,
> > reds->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds));
> > - reds->agent_state->read_filter.discard_all = FALSE;
> > - reds->agent_state->plug_generation++;
> > + reds->agent_state->priv->read_filter.discard_all = FALSE;
> > + reds->agent_state->priv->plug_generation++;
> > }
> >
> > if (!mig_target) {
> > @@ -3025,7 +3030,7 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > SpiceCharDeviceInterface *sif;
> > RedCharDeviceCallbacks char_dev_state_cbs;
> >
> > - if (!state->base) {
> > + if (!state->priv->base) {
> > char_dev_state_cbs.read_one_msg_from_device =
> > vdi_port_read_one_msg_from_device;
> > char_dev_state_cbs.ref_msg_to_client = vdi_port_ref_msg_to_client;
> > char_dev_state_cbs.unref_msg_to_client =
> > vdi_port_unref_msg_to_client;
> > @@ -3034,14 +3039,14 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > char_dev_state_cbs.remove_client = vdi_port_remove_client;
> > char_dev_state_cbs.on_free_self_token =
> > vdi_port_on_free_self_token;
> >
> > - state->base = red_char_device_create(sin,
> > - reds,
> > - REDS_TOKENS_TO_SEND,
> > -
> > REDS_NUM_INTERNAL_AGENT_MESSAGES,
> > - &char_dev_state_cbs,
> > - reds);
> > + state->priv->base = red_char_device_create(sin,
> > + reds,
> > + REDS_TOKENS_TO_SEND,
> > +
> > REDS_NUM_INTERNAL_AGENT_MESSAGES,
> > + &char_dev_state_cbs,
> > + reds);
> > } else {
> > - red_char_device_reset_dev_instance(state->base, sin);
> > + red_char_device_reset_dev_instance(state->priv->base, sin);
> > }
> >
> > reds->vdagent = sin;
> > @@ -3053,13 +3058,13 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > }
> >
> > if (!reds_main_channel_connected(reds)) {
> > - return state->base;
> > + return state->priv->base;
> > }
> >
> > - state->read_filter.discard_all = FALSE;
> > - reds->agent_state->plug_generation++;
> > + state->priv->read_filter.discard_all = FALSE;
> > + reds->agent_state->priv->plug_generation++;
> >
> > - if (reds->agent_state->mig_data ||
> > + if (reds->agent_state->priv->mig_data ||
> > red_channel_is_waiting_for_migrate_data(&reds->main_channel->base))
> > {
> > /* Migration in progress (code is running on the destination host):
> > * 1. Add the client to spice char device, if it was not already
> > added.
> > @@ -3068,10 +3073,10 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > * 2.b If this happens second ==> we already have spice migrate
> > data
> > * then restore state
> > */
> > - if (!red_char_device_client_exists(reds->agent_state->base,
> > reds_get_client(reds))) {
> > + if (!red_char_device_client_exists(reds->agent_state->priv->base,
> > reds_get_client(reds))) {
> > int client_added;
> >
> > - client_added = red_char_device_client_add(reds->agent_state
> > ->base,
> > + client_added = red_char_device_client_add(reds->agent_state
> > ->priv
> > ->base,
> >
> > reds_get_client(reds),
> > TRUE, /* flow control
> > */
> >
> > REDS_VDI_PORT_NUM_RECEIVE_BUFFS,
> > @@ -3085,12 +3090,12 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > }
> > }
> >
> > - if (reds->agent_state->mig_data) {
> > + if (reds->agent_state->priv->mig_data) {
> > spice_debug("restoring state from stored migration data");
> > - spice_assert(reds->agent_state->plug_generation == 1);
> > - reds_agent_state_restore(reds, reds->agent_state->mig_data);
> > - free(reds->agent_state->mig_data);
> > - reds->agent_state->mig_data = NULL;
> > + spice_assert(reds->agent_state->priv->plug_generation == 1);
> > + reds_agent_state_restore(reds, reds->agent_state->priv
> > ->mig_data);
> > + free(reds->agent_state->priv->mig_data);
> > + reds->agent_state->priv->mig_data = NULL;
> > }
> > else {
> > spice_debug("waiting for migration data");
> > @@ -3101,7 +3106,7 @@ static RedCharDevice *attach_to_red_agent(RedsState
> > *reds, SpiceCharDeviceInstan
> > main_channel_push_agent_connected(reds->main_channel);
> > }
> >
> > - return state->base;
> > + return state->priv->base;
> > }
> >
> > SPICE_GNUC_VISIBLE void
> > spice_server_char_device_wakeup(SpiceCharDeviceInstance* sin)
> > @@ -3365,23 +3370,23 @@ static void reds_init_vd_agent_resources(RedsState
> > *reds)
> >
> > reds->agent_state = g_new0(VDIPortState, 1);
> > state = reds->agent_state;
> > - ring_init(&state->read_bufs);
> > - agent_msg_filter_init(&state->write_filter, reds->agent_copypaste,
> > + ring_init(&state->priv->read_bufs);
> > + agent_msg_filter_init(&state->priv->write_filter, reds
> > ->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds), TRUE);
> > - agent_msg_filter_init(&state->read_filter, reds->agent_copypaste,
> > + agent_msg_filter_init(&state->priv->read_filter, reds->agent_copypaste,
> > reds->agent_file_xfer,
> > reds_use_client_monitors_config(reds), TRUE);
> >
> > - state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > - state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
> > - state->receive_len = sizeof(state->vdi_chunk_header);
> > + state->priv->read_state = VDI_PORT_READ_STATE_READ_HEADER;
> > + state->priv->receive_pos = (uint8_t *)&state->priv->vdi_chunk_header;
> > + state->priv->receive_len = sizeof(state->priv->vdi_chunk_header);
> >
> > for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
> > VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);
> > buf->state = state;
> > ring_item_init(&buf->link);
> > - ring_add(&reds->agent_state->read_bufs, &buf->link);
> > + ring_add(&reds->agent_state->priv->read_bufs, &buf->link);
> > }
> > }
> >
> > @@ -3868,16 +3873,16 @@ SPICE_GNUC_VISIBLE int
> > spice_server_set_agent_mouse(SpiceServer *reds, int enabl
> > SPICE_GNUC_VISIBLE int spice_server_set_agent_copypaste(SpiceServer *reds,
> > int enable)
> > {
> > reds->agent_copypaste = enable;
> > - reds->agent_state->write_filter.copy_paste_enabled = reds
> > ->agent_copypaste;
> > - reds->agent_state->read_filter.copy_paste_enabled = reds
> > ->agent_copypaste;
> > + reds->agent_state->priv->write_filter.copy_paste_enabled = reds
> > ->agent_copypaste;
> > + reds->agent_state->priv->read_filter.copy_paste_enabled = reds
> > ->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_state->write_filter.file_xfer_enabled = reds
> > ->agent_file_xfer;
> > - reds->agent_state->read_filter.file_xfer_enabled = reds
> > ->agent_file_xfer;
> > + reds->agent_state->priv->write_filter.file_xfer_enabled = reds
> > ->agent_file_xfer;
> > + reds->agent_state->priv->read_filter.file_xfer_enabled = reds
> > ->agent_file_xfer;
> > return 0;
> > }
> >
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel