Use RED_CHANNEL_CLIENT() macro for castingreview-20160907

Also remove (main|inputs)_channel_client_get_base() function to prepare
for porting to GObject.

8 files changed, 74 insertions, 72 deletions

diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
index ce38a2a4..034f2eab 100644
--- a/server/cache-item.tmpl.c
+++ b/server/cache-item.tmpl.c
@@ -78,7 +78,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
     channel_client->priv->VAR_NAME(available) += item->u.cache_data.size;
 
     red_pipe_item_init(&item->u.pipe_data, RED_PIPE_ITEM_TYPE_INVAL_ONE);
-    red_channel_client_pipe_add_tail_and_push(&channel_client->base, &item->u.pipe_data); // for now
+    red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(channel_client), &item->u.pipe_data); // for now
 }
 
 static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t size)
diff --git a/server/dcc.c b/server/dcc.c
index 5eca7f56..36c9c1d2 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -546,15 +546,15 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
         return;
     }
 
-    if (!red_channel_client_test_remote_cap(&dcc->base,
+    if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc),
                                             SPICE_DISPLAY_CAP_MONITORS_CONFIG)) {
         return;
     }
 
-    mci = red_monitors_config_item_new(red_channel_client_get_channel(&dcc->base),
+    mci = red_monitors_config_item_new(red_channel_client_get_channel(RED_CHANNEL_CLIENT(dcc)),
                                        monitors_config_ref(dc->monitors_config));
-    red_channel_client_pipe_add(&dcc->base, &mci->pipe_item);
-    red_channel_client_push(&dcc->base);
+    red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &mci->pipe_item);
+    red_channel_client_push(RED_CHANNEL_CLIENT(dcc));
 }
 
 static RedSurfaceDestroyItem *red_surface_destroy_item_new(RedChannel *channel,
@@ -749,7 +749,7 @@ int dcc_compress_image(DisplayChannelClient *dcc,
         goto lz_compress;
 #ifdef USE_LZ4
     case SPICE_IMAGE_COMPRESSION_LZ4:
-        if (red_channel_client_test_remote_cap(&dcc->base,
+        if (red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc),
                                                SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
             success = image_encoders_compress_lz4(&dcc->priv->encoders, dest, src, o_comp_data);
             break;
diff --git a/server/inputs-channel-client.c b/server/inputs-channel-client.c
index 6e352dc8..a07008b1 100644
--- a/server/inputs-channel-client.c
+++ b/server/inputs-channel-client.c
@@ -56,7 +56,7 @@ RedChannelClient* inputs_channel_client_create(RedChannel *channel,
     if (icc) {
         icc->priv->motion_count = 0;
     }
-    return &icc->base;
+    return RED_CHANNEL_CLIENT(icc);
 }
 
 void inputs_channel_client_send_migrate_data(RedChannelClient *rcc,
@@ -79,17 +79,19 @@ void inputs_channel_client_handle_migrate_data(InputsChannelClient *icc,
 
     for (; icc->priv->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
            icc->priv->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
-        red_channel_client_pipe_add_type(&icc->base, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
+        red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(icc),
+                                         RED_PIPE_ITEM_MOUSE_MOTION_ACK);
     }
 }
 
 void inputs_channel_client_on_mouse_motion(InputsChannelClient *icc)
 {
-    InputsChannel *inputs_channel = (InputsChannel *)red_channel_client_get_channel(&icc->base);
+    InputsChannel *inputs_channel = (InputsChannel *)red_channel_client_get_channel(RED_CHANNEL_CLIENT(icc));
 
     if (++icc->priv->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
         !inputs_channel_is_src_during_migrate(inputs_channel)) {
-        red_channel_client_pipe_add_type(&icc->base, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
+        red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(icc),
+                                         RED_PIPE_ITEM_MOUSE_MOTION_ACK);
         icc->priv->motion_count = 0;
     }
 }
diff --git a/server/main-channel-client.c b/server/main-channel-client.c
index 75aae9f5..d9315e18 100644
--- a/server/main-channel-client.c
+++ b/server/main-channel-client.c
@@ -158,7 +158,8 @@ void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate)
             mcc->priv->net_test_stage = NET_TEST_STAGE_WARMUP;
         }
     } else {
-        red_channel_client_start_connectivity_monitoring(&mcc->base, CLIENT_CONNECTIVITY_TIMEOUT);
+        red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc),
+                                                         CLIENT_CONNECTIVITY_TIMEOUT);
     }
 }
 
@@ -179,7 +180,7 @@ static int main_channel_client_push_ping(MainChannelClient *mcc, int size)
         return FALSE;
     }
     item = red_ping_item_new(size);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
     return TRUE;
 }
 
@@ -197,7 +198,7 @@ void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_
 {
     RedPipeItem *item = main_agent_tokens_item_new(num_tokens);
 
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 static void main_agent_data_item_free(RedPipeItem *base)
@@ -228,7 +229,7 @@ void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data,
     RedPipeItem *item;
 
     item = main_agent_data_item_new(data, len, free_data, opaque);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 static RedPipeItem *main_init_item_new(int connection_id,
@@ -262,7 +263,7 @@ void main_channel_client_push_init(MainChannelClient *mcc,
     item = main_init_item_new(mcc->priv->connection_id, display_channels_hint,
                               current_mouse_mode, is_client_mouse_allowed,
                               multi_media_time, ram_hint);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 static RedPipeItem *main_name_item_new(const char *name)
@@ -280,12 +281,12 @@ void main_channel_client_push_name(MainChannelClient *mcc, const char *name)
 {
     RedPipeItem *item;
 
-    if (!red_channel_client_test_remote_cap(&mcc->base,
+    if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc),
                                             SPICE_MAIN_CAP_NAME_AND_UUID))
         return;
 
     item = main_name_item_new(name);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 static RedPipeItem *main_uuid_item_new(const uint8_t uuid[16])
@@ -302,18 +303,18 @@ void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16
 {
     RedPipeItem *item;
 
-    if (!red_channel_client_test_remote_cap(&mcc->base,
+    if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc),
                                             SPICE_MAIN_CAP_NAME_AND_UUID))
         return;
 
     item = main_uuid_item_new(uuid);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
 {
     RedPipeItem *item = main_notify_item_new(msg, 1);
-    red_channel_client_pipe_add_push(&mcc->base, item);
+    red_channel_client_pipe_add_push(RED_CHANNEL_CLIENT(mcc), item);
 }
 
 RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
@@ -343,10 +344,10 @@ void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
                                                   int success,
                                                   int seamless)
 {
-    RedClient *client = red_channel_client_get_client(&mcc->base);
+    RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc));
     spice_printerr("client %p connected: %d seamless %d", client, success, seamless);
     if (mcc->priv->mig_wait_connect) {
-        RedChannel *channel = red_channel_client_get_channel(&mcc->base);
+        RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
         MainChannel *main_channel = SPICE_CONTAINEROF(channel, MainChannel, base);
 
         mcc->priv->mig_wait_connect = FALSE;
@@ -359,7 +360,8 @@ void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
     } else {
         if (success) {
             spice_printerr("client %p MIGRATE_CANCEL", client);
-            red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
+            red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc),
+                                                  SPICE_MSG_MAIN_MIGRATE_CANCEL);
         }
     }
 }
@@ -367,13 +369,13 @@ void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
 void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
                                                         uint32_t src_version)
 {
-    RedChannel *channel = red_channel_client_get_channel(&mcc->base);
+    RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
     if (reds_on_migrate_dst_set_seamless(channel->reds, mcc, src_version)) {
         mcc->priv->seamless_mig_dst = TRUE;
-        red_channel_client_pipe_add_empty_msg(&mcc->base,
+        red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc),
                                              SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
     } else {
-        red_channel_client_pipe_add_empty_msg(&mcc->base,
+        red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc),
                                               SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
     }
 }
@@ -405,7 +407,7 @@ void main_channel_client_handle_pong(MainChannelClient *mcc, SpiceMsgPing *ping,
                                    "bandwidth", mcc->priv->latency, roundtrip);
                     mcc->priv->latency = 0;
                     mcc->priv->net_test_stage = NET_TEST_STAGE_INVALID;
-                    red_channel_client_start_connectivity_monitoring(&mcc->base,
+                    red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc),
                                                                      CLIENT_CONNECTIVITY_TIMEOUT);
                     break;
                 }
@@ -417,7 +419,7 @@ void main_channel_client_handle_pong(MainChannelClient *mcc, SpiceMsgPing *ping,
                                mcc->priv->bitrate_per_sec,
                                (double)mcc->priv->bitrate_per_sec / 1024 / 1024,
                                main_channel_client_is_low_bandwidth(mcc) ? " LOW BANDWIDTH" : "");
-                red_channel_client_start_connectivity_monitoring(&mcc->base,
+                red_channel_client_start_connectivity_monitoring(RED_CHANNEL_CLIENT(mcc),
                                                                  CLIENT_CONNECTIVITY_TIMEOUT);
                 break;
             default:
@@ -441,12 +443,12 @@ void main_channel_client_handle_pong(MainChannelClient *mcc, SpiceMsgPing *ping,
 
 void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
 {
-    RedClient *client = red_channel_client_get_client(&mcc->base);
+    RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc));
     if (!red_client_during_migrate_at_target(client)) {
         spice_printerr("unexpected SPICE_MSGC_MIGRATE_END");
         return;
     }
-    if (!red_channel_client_test_remote_cap(&mcc->base,
+    if (!red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(mcc),
                                             SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
         spice_printerr("unexpected SPICE_MSGC_MIGRATE_END, "
                    "client does not support semi-seamless migration");
@@ -459,7 +461,7 @@ void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc)
 {
     if (mcc->priv->mig_wait_connect) {
         spice_printerr("client %p cancel wait connect",
-                       red_channel_client_get_client(&mcc->base));
+                       red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc)));
         mcc->priv->mig_wait_connect = FALSE;
         mcc->priv->mig_connect_ok = FALSE;
     }
@@ -470,12 +472,13 @@ void main_channel_client_migrate_dst_complete(MainChannelClient *mcc)
 {
     if (mcc->priv->mig_wait_prev_complete) {
         if (mcc->priv->mig_wait_prev_try_seamless) {
-            RedChannel *channel = red_channel_client_get_channel(&mcc->base);
+            RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
             spice_assert(g_list_length(channel->clients) == 1);
-            red_channel_client_pipe_add_type(&mcc->base,
+            red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc),
                                              RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
         } else {
-            red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+            red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc),
+                                             RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
         }
         mcc->priv->mig_wait_connect = TRUE;
         mcc->priv->mig_wait_prev_complete = FALSE;
@@ -486,22 +489,26 @@ gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
                                                   gboolean success)
 {
     gboolean ret = FALSE;
-    RedClient *client = red_channel_client_get_client(&mcc->base);
-    int semi_seamless_support = red_channel_client_test_remote_cap(&mcc->base,
+    RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
+    RedClient *client = red_channel_client_get_client(rcc);
+    int semi_seamless_support = red_channel_client_test_remote_cap(rcc,
                                                                    SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
     if (semi_seamless_support && mcc->priv->mig_connect_ok) {
         if (success) {
             spice_printerr("client %p MIGRATE_END", client);
-            red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_END);
+            red_channel_client_pipe_add_empty_msg(rcc,
+                                                  SPICE_MSG_MAIN_MIGRATE_END);
             ret = TRUE;
         } else {
             spice_printerr("client %p MIGRATE_CANCEL", client);
-            red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
+            red_channel_client_pipe_add_empty_msg(rcc,
+                                                  SPICE_MSG_MAIN_MIGRATE_CANCEL);
         }
     } else {
         if (success) {
             spice_printerr("client %p SWITCH_HOST", client);
-            red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+            red_channel_client_pipe_add_type(rcc,
+                                             RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
         }
     }
     mcc->priv->mig_connect_ok = FALSE;
@@ -514,7 +521,7 @@ gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
 static void do_ping_client(MainChannelClient *mcc,
     const char *opt, int has_interval, int interval)
 {
-    RedChannel *channel = red_channel_client_get_channel(&mcc->base);
+    RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
     spice_printerr("");
     if (!opt) {
         main_channel_client_push_ping(mcc, 0);
@@ -533,9 +540,9 @@ static void do_ping_client(MainChannelClient *mcc,
 static void ping_timer_cb(void *opaque)
 {
     MainChannelClient *mcc = opaque;
-    RedChannel *channel = red_channel_client_get_channel(&mcc->base);
+    RedChannel *channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
 
-    if (!red_channel_client_is_connected(&mcc->base)) {
+    if (!red_channel_client_is_connected(RED_CHANNEL_CLIENT(mcc))) {
         spice_printerr("not connected to peer, ping off");
         reds_core_timer_cancel(channel->reds, mcc->priv->ping_timer);
         return;
@@ -596,7 +603,7 @@ void main_channel_client_migrate(RedChannelClient *rcc)
 
 gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
 {
-    RedChannelClient *rcc = main_channel_client_get_base(mcc);
+    RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
     MainChannel* main_channel = (MainChannel*)red_channel_client_get_channel(rcc);
     if (red_channel_client_test_remote_cap(rcc,
                                            SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
@@ -619,27 +626,22 @@ gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
 
 void main_channel_client_connect_seamless(MainChannelClient *mcc)
 {
-    RedClient *client = red_channel_client_get_client(&mcc->base);
-    spice_assert(red_channel_client_test_remote_cap(&mcc->base,
+    RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
+    RedClient *client = red_channel_client_get_client(rcc);
+    spice_assert(red_channel_client_test_remote_cap(rcc,
                                                     SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
     if (red_client_during_migrate_at_target(client)) {
         spice_printerr("client %p: wait till previous migration completes", client);
         mcc->priv->mig_wait_prev_complete = TRUE;
         mcc->priv->mig_wait_prev_try_seamless = TRUE;
     } else {
-        red_channel_client_pipe_add_type(&mcc->base,
+        red_channel_client_pipe_add_type(rcc,
                                          RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
         mcc->priv->mig_wait_connect = TRUE;
     }
     mcc->priv->mig_connect_ok = FALSE;
 }
 
-RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc)
-{
-    spice_assert(mcc);
-    return &mcc->base;
-}
-
 uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc)
 {
     return mcc->priv->connection_id;
diff --git a/server/main-channel-client.h b/server/main-channel-client.h
index c74f8479..9f05af39 100644
--- a/server/main-channel-client.h
+++ b/server/main-channel-client.h
@@ -66,8 +66,6 @@ int main_channel_client_is_low_bandwidth(MainChannelClient *mcc);
 uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc);
 uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc);
 
-RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc);
-
 void main_channel_client_push_name(MainChannelClient *mcc, const char *name);
 void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]);
 
diff --git a/server/main-channel.c b/server/main-channel.c
index 24c69a40..46703157 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -58,13 +58,13 @@ RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t c
 
 static void main_channel_push_channels(MainChannelClient *mcc)
 {
-    RedChannelClient *rcc = main_channel_client_get_base(mcc);
+    RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
     if (red_client_during_migrate_at_target(red_channel_client_get_client(rcc))) {
         spice_printerr("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS"
                    "during migration");
         return;
     }
-    red_channel_client_pipe_add_type(main_channel_client_get_base(mcc), RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
+    red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc), RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
 }
 
 void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
diff --git a/server/reds.c b/server/reds.c
index e75e1fd0..f9177fc7 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -934,8 +934,7 @@ static void vdi_port_on_free_self_token(void *opaque)
 
 static void vdi_port_remove_client(RedClient *client, void *opaque)
 {
-    red_channel_client_shutdown(main_channel_client_get_base(
-                                    red_client_get_main(client)));
+    red_channel_client_shutdown(RED_CHANNEL_CLIENT(red_client_get_main(client)));
 }
 
 /****************************************************************************/
@@ -1049,7 +1048,7 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
         return;
     }
     spice_assert(reds->vdagent->st && reds->vdagent->st == dev_state);
-    rcc = main_channel_client_get_base(mcc);
+    rcc = RED_CHANNEL_CLIENT(mcc);
     client = red_channel_client_get_client(rcc);
     reds->agent_dev->priv->client_agent_started = TRUE;
     /*
@@ -1089,7 +1088,7 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
 
 void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc, uint32_t num_tokens)
 {
-    RedClient *client = red_channel_client_get_client(main_channel_client_get_base(mcc));
+    RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc));
     if (!reds->vdagent) {
         return;
     }
@@ -1116,7 +1115,7 @@ uint8_t *reds_get_agent_data_buffer(RedsState *reds, MainChannelClient *mcc, siz
     }
 
     spice_assert(dev->priv->recv_from_client_buf == NULL);
-    client = red_channel_client_get_client(main_channel_client_get_base(mcc));
+    client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc));
     dev->priv->recv_from_client_buf = red_char_device_write_buffer_get(RED_CHAR_DEVICE(dev),
                                                                        client,
                                                                        size + sizeof(VDIChunkHeader));
@@ -1200,7 +1199,7 @@ void reds_on_main_agent_data(RedsState *reds, MainChannelClient *mcc, void *mess
         reds_on_main_agent_monitors_config(reds, mcc, message, size);
         return;
     case AGENT_MSG_FILTER_PROTO_ERROR:
-        red_channel_client_shutdown(main_channel_client_get_base(mcc));
+        red_channel_client_shutdown(RED_CHANNEL_CLIENT(mcc));
         return;
     }
 
@@ -1487,7 +1486,7 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc,
     } else {
         spice_debug("agent was not attached on the source host");
         if (reds->vdagent) {
-            RedClient *client = red_channel_client_get_client(main_channel_client_get_base(mcc));
+            RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(mcc));
             /* red_char_device_client_remove disables waiting for migration data */
             red_char_device_client_remove(RED_CHAR_DEVICE(agent_dev), client);
             main_channel_push_agent_connected(reds->main_channel);
@@ -1932,7 +1931,7 @@ int reds_on_migrate_dst_set_seamless(RedsState *reds, MainChannelClient *mcc, ui
     if (reds->allow_multiple_clients  || src_version > SPICE_MIGRATION_PROTOCOL_VERSION) {
         reds->dst_do_seamless_migrate = FALSE;
     } else {
-        RedChannelClient *rcc = main_channel_client_get_base(mcc);
+        RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
         RedClient *client = red_channel_client_get_client(rcc);
 
         red_client_set_migration_seamless(client);
diff --git a/server/smartcard.c b/server/smartcard.c
index c2d5451e..3ea8a258 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -326,18 +326,18 @@ static void smartcard_char_device_attach_client(SpiceCharDeviceInstance *char_de
     dev->priv->scc = scc;
     scc->priv->smartcard = dev;
     client_added = red_char_device_client_add(RED_CHAR_DEVICE(dev),
-                                              red_channel_client_get_client(&scc->base),
+                                              red_channel_client_get_client(RED_CHANNEL_CLIENT(scc)),
                                               FALSE, /* no flow control yet */
                                               0, /* send queue size */
                                               ~0,
                                               ~0,
                                               red_channel_client_is_waiting_for_migrate_data(
-                                                  &scc->base));
+                                                  RED_CHANNEL_CLIENT(scc)));
     if (!client_added) {
         spice_warning("failed");
         dev->priv->scc = NULL;
         scc->priv->smartcard = NULL;
-        red_channel_client_disconnect(&scc->base);
+        red_channel_client_disconnect(RED_CHANNEL_CLIENT(scc));
     }
 }
 
@@ -373,7 +373,7 @@ static void smartcard_char_device_detach_client(SmartCardChannelClient *scc)
     dev = scc->priv->smartcard;
     spice_assert(dev->priv->scc == scc);
     red_char_device_client_remove(RED_CHAR_DEVICE(dev),
-                                  red_channel_client_get_client(&scc->base));
+                                  red_channel_client_get_client(RED_CHANNEL_CLIENT(scc)));
     scc->priv->smartcard = NULL;
     dev->priv->scc = NULL;
 }
@@ -573,14 +573,14 @@ static void smartcard_remove_reader(SmartCardChannelClient *scc, uint32_t reader
     RedCharDeviceSmartcard *dev;
 
     if (char_device == NULL) {
-        smartcard_push_error(&scc->base, reader_id,
+        smartcard_push_error(RED_CHANNEL_CLIENT(scc), reader_id,
             VSC_GENERAL_ERROR);
         return;
     }
 
     dev = red_char_device_opaque_get(char_device->st);
     if (dev->priv->reader_added == FALSE) {
-        smartcard_push_error(&scc->base, reader_id,
+        smartcard_push_error(RED_CHANNEL_CLIENT(scc), reader_id,
             VSC_GENERAL_ERROR);
         return;
     }
@@ -595,7 +595,8 @@ static void smartcard_add_reader(SmartCardChannelClient *scc, uint8_t *name)
         SpiceCharDeviceInstance *char_device = smartcard_readers_get_unattached();
 
         if (!char_device) {
-            smartcard_push_error(&scc->base, VSCARD_UNDEFINED_READER_ID,
+            smartcard_push_error(RED_CHANNEL_CLIENT(scc),
+                                 VSCARD_UNDEFINED_READER_ID,
                                 VSC_CANNOT_ADD_MORE_READERS);
             return;
         }
@@ -769,7 +770,7 @@ static void smartcard_connect_client(RedChannel *channel, RedClient *client,
     if (!scc) {
         return;
     }
-    red_channel_client_ack_zero_messages_window(&scc->base);
+    red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(scc));
 
     if (char_device) {
         smartcard_char_device_attach_client(char_device, scc);