>
> After renaming the object to RedVmcChannel, the local variables still
> used the old 'state' terminology. Changing these variables to 'channel'
> makes things a bit more consistent.
> ---
> server/spicevmc.c | 146
> +++++++++++++++++++++++++++---------------------------
> 1 file changed, 73 insertions(+), 73 deletions(-)
>
> diff --git a/server/spicevmc.c b/server/spicevmc.c
> index 49de9cc..664896c 100644
> --- a/server/spicevmc.c
> +++ b/server/spicevmc.c
> @@ -328,12 +328,12 @@ static void
> spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
> * - a new pipe item with the compressed data in it upon success
> */
> #ifdef USE_LZ4
> -static RedVmcPipeItem* try_compress_lz4(RedVmcChannel *state, int n,
> RedVmcPipeItem *msg_item)
> +static RedVmcPipeItem* try_compress_lz4(RedVmcChannel *channel, int n,
> RedVmcPipeItem *msg_item)
> {
> RedVmcPipeItem *msg_item_compressed;
> int compressed_data_count;
>
> - if (reds_stream_get_family(red_channel_client_get_stream(state->rcc)) ==
> AF_UNIX) {
> + if (reds_stream_get_family(red_channel_client_get_stream(channel->rcc))
> == AF_UNIX) {
> /* AF_LOCAL - data will not be compressed */
> return NULL;
> }
> @@ -341,7 +341,7 @@ static RedVmcPipeItem* try_compress_lz4(RedVmcChannel
> *state, int n, RedVmcPipeI
> /* n <= threshold - data will not be compressed */
> return NULL;
> }
> - if (!red_channel_test_remote_cap(RED_CHANNEL(state),
> SPICE_SPICEVMC_CAP_DATA_COMPRESS_LZ4)) {
> + if (!red_channel_test_remote_cap(RED_CHANNEL(channel),
> SPICE_SPICEVMC_CAP_DATA_COMPRESS_LZ4)) {
> /* Client doesn't have compression cap - data will not be compressed
> */
> return NULL;
> }
> @@ -370,25 +370,25 @@ static RedPipeItem
> *spicevmc_chardev_read_msg_from_dev(RedCharDevice *self,
> SpiceCharDeviceInstance
> *sin)
> {
> RedCharDeviceSpiceVmc *vmc = RED_CHAR_DEVICE_SPICEVMC(self);
> - RedVmcChannel *state = RED_VMC_CHANNEL(vmc->channel);
> + RedVmcChannel *channel = RED_VMC_CHANNEL(vmc->channel);
> SpiceCharDeviceInterface *sif;
> RedVmcPipeItem *msg_item;
> int n;
>
> sif = spice_char_device_get_interface(sin);
>
> - if (!state->rcc) {
> + if (!channel->rcc) {
> return NULL;
> }
>
> - if (!state->pipe_item) {
> + if (!channel->pipe_item) {
> msg_item = spice_new0(RedVmcPipeItem, 1);
> msg_item->type = SPICE_DATA_COMPRESSION_TYPE_NONE;
> 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;
> - state->pipe_item = NULL;
> + spice_assert(channel->pipe_item->buf_used == 0);
> + msg_item = channel->pipe_item;
> + channel->pipe_item = NULL;
> }
>
> n = sif->read(sin, msg_item->buf,
> @@ -398,7 +398,7 @@ static RedPipeItem
> *spicevmc_chardev_read_msg_from_dev(RedCharDevice *self,
> #ifdef USE_LZ4
> RedVmcPipeItem *msg_item_compressed;
>
> - msg_item_compressed = try_compress_lz4(state, n, msg_item);
> + msg_item_compressed = try_compress_lz4(channel, n, msg_item);
> if (msg_item_compressed != NULL) {
> return &msg_item_compressed->base;
> }
> @@ -407,7 +407,7 @@ static RedPipeItem
> *spicevmc_chardev_read_msg_from_dev(RedCharDevice *self,
> msg_item->buf_used = n;
> return &msg_item->base;
> } else {
> - state->pipe_item = msg_item;
> + channel->pipe_item = msg_item;
> return NULL;
> }
> }
> @@ -417,24 +417,24 @@ static void
> spicevmc_chardev_send_msg_to_client(RedCharDevice *self,
> RedClient *client)
> {
> RedCharDeviceSpiceVmc *vmc = RED_CHAR_DEVICE_SPICEVMC(self);
> - RedVmcChannel *state = RED_VMC_CHANNEL(vmc->channel);
> + RedVmcChannel *channel = RED_VMC_CHANNEL(vmc->channel);
>
> - spice_assert(red_channel_client_get_client(state->rcc) == client);
> + spice_assert(red_channel_client_get_client(channel->rcc) == client);
> red_pipe_item_ref(msg);
> - red_channel_client_pipe_add_push(state->rcc, msg);
> + red_channel_client_pipe_add_push(channel->rcc, msg);
> }
>
> static void spicevmc_port_send_init(RedChannelClient *rcc)
> {
> - RedVmcChannel *state =
> RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + RedVmcChannel *channel =
> RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> SpiceCharDeviceInstance *sin;
> RedPortInitPipeItem *item = spice_malloc(sizeof(RedPortInitPipeItem));
>
> - g_object_get(state->chardev, "sin", &sin, NULL);
> + g_object_get(channel->chardev, "sin", &sin, NULL);
>
> red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_INIT);
> item->name = strdup(sin->portname);
> - item->opened = state->port_opened;
> + item->opened = channel->port_opened;
> red_channel_client_pipe_add_push(rcc, &item->base);
> }
>
> @@ -458,13 +458,13 @@ static void
> spicevmc_char_dev_remove_client(RedCharDevice *self,
> RedClient *client)
> {
> RedCharDeviceSpiceVmc *vmc = RED_CHAR_DEVICE_SPICEVMC(self);
> - RedVmcChannel *state = RED_VMC_CHANNEL(vmc->channel);
> + RedVmcChannel *channel = RED_VMC_CHANNEL(vmc->channel);
>
> - spice_printerr("vmc state %p, client %p", state, client);
> - spice_assert(state->rcc &&
> - red_channel_client_get_client(state->rcc) == client);
> + spice_printerr("vmc channel %p, client %p", channel, client);
> + spice_assert(channel->rcc &&
> + red_channel_client_get_client(channel->rcc) == client);
>
> - red_channel_client_shutdown(state->rcc);
> + red_channel_client_shutdown(channel->rcc);
> }
>
> static int spicevmc_red_channel_client_config_socket(RedChannelClient *rcc)
> @@ -490,7 +490,7 @@ static int
> spicevmc_red_channel_client_config_socket(RedChannelClient *rcc)
>
> static void spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
> {
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
> SpiceCharDeviceInstance *sin;
> SpiceCharDeviceInterface *sif;
> RedClient *client = red_channel_client_get_client(rcc);
> @@ -499,17 +499,17 @@ static void
> spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
> return;
> }
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
>
> /* partial message which wasn't pushed to device */
> - red_char_device_write_buffer_release(state->chardev,
> &state->recv_from_client_buf);
> + red_char_device_write_buffer_release(channel->chardev,
> &channel->recv_from_client_buf);
>
> - g_object_get(state->chardev, "sin", &sin, NULL);
> - if (red_char_device_client_exists(state->chardev, client)) {
> - red_char_device_client_remove(state->chardev, client);
> + g_object_get(channel->chardev, "sin", &sin, NULL);
> + if (red_char_device_client_exists(channel->chardev, client)) {
> + red_char_device_client_remove(channel->chardev, client);
> } else {
> spice_printerr("client %p have already been removed from char dev
> %p",
> - client, state->chardev);
> + client, channel->chardev);
> }
>
> /* Don't destroy the rcc if it is already being destroyed, as then
> @@ -517,7 +517,7 @@ static void
> spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
> if (!red_channel_client_is_destroying(rcc))
> red_channel_client_destroy(rcc);
>
> - state->rcc = NULL;
> + channel->rcc = NULL;
> sif = spice_char_device_get_interface(sin);
> if (sif->state) {
> sif->state(sin, 0);
> @@ -535,9 +535,9 @@ static int
> spicevmc_channel_client_handle_migrate_data(RedChannelClient *rcc,
> {
> SpiceMigrateDataHeader *header;
> SpiceMigrateDataSpiceVmc *mig_data;
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
>
> header = (SpiceMigrateDataHeader *)message;
> mig_data = (SpiceMigrateDataSpiceVmc *)(header + 1);
> @@ -549,17 +549,17 @@ static int
> spicevmc_channel_client_handle_migrate_data(RedChannelClient *rcc,
> spice_error("bad header");
> return FALSE;
> }
> - return red_char_device_restore(state->chardev, &mig_data->base);
> + return red_char_device_restore(channel->chardev, &mig_data->base);
> }
>
> -static int handle_compressed_msg(RedVmcChannel *state, RedChannelClient
> *rcc,
> +static int handle_compressed_msg(RedVmcChannel *channel, RedChannelClient
> *rcc,
> SpiceMsgCompressedData
> *compressed_data_msg)
> {
> /* NOTE: *decompressed is free by the char-device */
> int decompressed_size;
> RedCharDeviceWriteBuffer *write_buf;
>
> - write_buf = red_char_device_write_buffer_get(state->chardev,
> + write_buf = red_char_device_write_buffer_get(channel->chardev,
> red_channel_client_get_client(rcc),
> compressed_data_msg->uncompressed_size);
> if (!write_buf) {
> @@ -579,16 +579,16 @@ static int handle_compressed_msg(RedVmcChannel *state,
> RedChannelClient *rcc,
> #endif
> default:
> spice_warning("Invalid Compression Type");
> - red_char_device_write_buffer_release(state->chardev, &write_buf);
> + red_char_device_write_buffer_release(channel->chardev, &write_buf);
> return FALSE;
> }
> if (decompressed_size != compressed_data_msg->uncompressed_size) {
> spice_warning("Decompression Error");
> - red_char_device_write_buffer_release(state->chardev, &write_buf);
> + red_char_device_write_buffer_release(channel->chardev, &write_buf);
> return FALSE;
> }
> write_buf->buf_used = decompressed_size;
> - red_char_device_write_buffer_add(state->chardev, write_buf);
> + red_char_device_write_buffer_add(channel->chardev, write_buf);
> return TRUE;
> }
>
> @@ -599,23 +599,23 @@ static int
> spicevmc_red_channel_client_handle_message_parsed(RedChannelClient *r
> {
> /* NOTE: *msg free by free() (when cb to
> spicevmc_red_channel_release_msg_rcv_buf
> * with the compressed msg type) */
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
> SpiceCharDeviceInstance *sin;
> SpiceCharDeviceInterface *sif;
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> - g_object_get(state->chardev, "sin", &sin, NULL);
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + g_object_get(channel->chardev, "sin", &sin, NULL);
> sif = spice_char_device_get_interface(sin);
>
> switch (type) {
> case SPICE_MSGC_SPICEVMC_DATA:
> - spice_assert(state->recv_from_client_buf->buf == msg);
> - state->recv_from_client_buf->buf_used = size;
> - red_char_device_write_buffer_add(state->chardev,
> state->recv_from_client_buf);
> - state->recv_from_client_buf = NULL;
> + spice_assert(channel->recv_from_client_buf->buf == msg);
> + channel->recv_from_client_buf->buf_used = size;
> + red_char_device_write_buffer_add(channel->chardev,
> channel->recv_from_client_buf);
> + channel->recv_from_client_buf = NULL;
> break;
> case SPICE_MSGC_SPICEVMC_COMPRESSED_DATA:
> - return handle_compressed_msg(state, rcc,
> (SpiceMsgCompressedData*)msg);
> + return handle_compressed_msg(channel, rcc,
> (SpiceMsgCompressedData*)msg);
> break;
> case SPICE_MSGC_PORT_EVENT:
> if (size != sizeof(uint8_t)) {
> @@ -636,23 +636,23 @@ static uint8_t
> *spicevmc_red_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
> uint16_t type,
> uint32_t size)
> {
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
> RedClient *client = red_channel_client_get_client(rcc);
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
>
> switch (type) {
> case SPICE_MSGC_SPICEVMC_DATA:
> - assert(!state->recv_from_client_buf);
> + assert(!channel->recv_from_client_buf);
>
> - state->recv_from_client_buf =
> red_char_device_write_buffer_get(state->chardev,
> -
> client,
> -
> size);
> - if (!state->recv_from_client_buf) {
> + channel->recv_from_client_buf =
> red_char_device_write_buffer_get(channel->chardev,
> +
> client,
> +
> size);
> + if (!channel->recv_from_client_buf) {
> spice_error("failed to allocate write buffer");
> return NULL;
> }
> - return state->recv_from_client_buf->buf;
> + return channel->recv_from_client_buf->buf;
>
> default:
> return spice_malloc(size);
> @@ -665,14 +665,14 @@ static void
> spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
> uint32_t size,
> uint8_t *msg)
> {
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
>
> switch (type) {
> case SPICE_MSGC_SPICEVMC_DATA:
> /* buffer wasn't pushed to device */
> - red_char_device_write_buffer_release(state->chardev,
> &state->recv_from_client_buf);
> + red_char_device_write_buffer_release(channel->chardev,
> &channel->recv_from_client_buf);
> break;
> default:
> free(msg);
> @@ -704,14 +704,14 @@ static void
> spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
> SpiceMarshaller *m,
> RedPipeItem *item)
> {
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
>
> - state = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> + channel = RED_VMC_CHANNEL(red_channel_client_get_channel(rcc));
> red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
> spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_MAGIC);
> spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_VERSION);
>
> - red_char_device_migrate_data_marshall(state->chardev, m);
> + red_char_device_migrate_data_marshall(channel->chardev, m);
> }
>
> static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
> @@ -828,18 +828,18 @@ static void spicevmc_connect(RedChannel *channel,
> RedClient *client,
> uint32_t *common_caps, int num_caps, uint32_t *caps)
> {
> RedChannelClient *rcc;
> - RedVmcChannel *state;
> + RedVmcChannel *vmc_channel;
> SpiceCharDeviceInstance *sin;
> SpiceCharDeviceInterface *sif;
> uint32_t type, id;
>
> - state = RED_VMC_CHANNEL(channel);
> + vmc_channel = RED_VMC_CHANNEL(channel);
> g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> - g_object_get(state->chardev, "sin", &sin, NULL);
> + g_object_get(vmc_channel->chardev, "sin", &sin, NULL);
>
> - if (state->rcc) {
> + if (vmc_channel->rcc) {
> spice_printerr("channel client %d:%d (%p) already connected,
> refusing second connection",
> - type, id, state->rcc);
> + type, id, vmc_channel->rcc);
> // TODO: notify client in advance about the in use channel using
> // SPICE_MSG_MAIN_CHANNEL_IN_USE (for example)
> reds_stream_free(stream);
> @@ -851,14 +851,14 @@ static void spicevmc_connect(RedChannel *channel,
> RedClient *client,
> if (!rcc) {
> return;
> }
> - state->rcc = rcc;
> + vmc_channel->rcc = rcc;
> red_channel_client_ack_zero_messages_window(rcc);
>
> if (strcmp(sin->subtype, "port") == 0) {
> spicevmc_port_send_init(rcc);
> }
>
> - if (!red_char_device_client_add(state->chardev, client, FALSE, 0, ~0,
> ~0,
> + if (!red_char_device_client_add(vmc_channel->chardev, client, FALSE, 0,
> ~0, ~0,
> red_channel_client_is_waiting_for_migrate_data(rcc)))
> {
> spice_warning("failed to add client to spicevmc");
> red_channel_client_disconnect(rcc);
> @@ -887,7 +887,7 @@ void spicevmc_device_disconnect(RedsState *reds,
> SpiceCharDeviceInstance *sin)
>
> SPICE_GNUC_VISIBLE void spice_server_port_event(SpiceCharDeviceInstance
> *sin, uint8_t event)
> {
> - RedVmcChannel *state;
> + RedVmcChannel *channel;
> RedCharDeviceSpiceVmc *device = RED_CHAR_DEVICE_SPICEVMC(sin->st);
>
> if (sin->st == NULL) {
> @@ -895,19 +895,19 @@ SPICE_GNUC_VISIBLE void
> spice_server_port_event(SpiceCharDeviceInstance *sin, ui
> return;
> }
>
> - state = RED_VMC_CHANNEL(device->channel);
> + channel = RED_VMC_CHANNEL(device->channel);
>
> if (event == SPICE_PORT_EVENT_OPENED) {
> - state->port_opened = TRUE;
> + channel->port_opened = TRUE;
> } else if (event == SPICE_PORT_EVENT_CLOSED) {
> - state->port_opened = FALSE;
> + channel->port_opened = FALSE;
> }
>
> - if (state->rcc == NULL) {
> + if (channel->rcc == NULL) {
> return;
> }
>
> - spicevmc_port_send_event(state->rcc, event);
> + spicevmc_port_send_event(channel->rcc, event);
> }
>
> static void
Acked-by: Frediano Ziglio <fziglio@xxxxxxxxxx>
Yes, state was quite confusing.
Frediano
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel